Today I tried the software I’ve been writing on another computer – and it immediately crashed. I got this error message:

Unhandled Exception: System.IO.FileNotFoundException: Could not load file or assembly ‘TrackerInterface-Mixed-Full.dll’ or one of its dependencies. The specified module could not be found.

Here, it tells me that my DLL “TrackerInterface-Mixed-Full.dll” could not be loaded. The first thing I thought was that the application couldn’t locate this DLL – because of the FileNotFoundException. Unfortunately this wasn’t the problem.

So I figured “or one of its dependencies” was the real problem. However, the error message doesn’t tell you what dependency (DLL) is actually missing – even when debugging.

So, I did some searching and found the Assembly Binding Log Viewer (or “Fusion Log Viewer”) which comes with Visual Studio. Unfortunately it didn’t do what I needed. It seems that this is actually more for .NET assemblies rather than native DLLs. (You need to run it with Adminstrator rights; otherwise it won’t work. Just in case you’ll ever need it.)

After some more searching I found a tool called Dependency Walker. And that’s exactly what did the trick. So I opened “TrackerInterface-Mixed-Full.dll” with it and got the following result:

Here you have my “TrackerInterface-Mixed-Full.dll” at the top of the tree and its dependencies listed below it. For one, you can see immediately that the file “QTCORED4.DLL” is missing. But you can also see that one dependency (“MAPPARSERD1.DLL”) is missing some dependencies as well. (Fortunately, Dependency Walker automatically expands all dependencies that again have missing dependencies.)

I hope this helps in case you’re running into this problem yourself.

Note: The part “The specified module could not be found.” of the error message indicates some missing DLLs. There can be other reasons for getting a “Could not load file or assembly ‘Assembly.dll’ or one of its dependencies.” which then have other texts after this one.

Note 2: This only seems to happen when using native DLLs from .NET applications/assemblies.

Last friday I stumbled over a seroius shortcomming of C++ (compared to C# or Java) I’d like to share here with you. It’s about virtual methods called from a class constructor.

The C# Example ∞

Let me start with an example. Here’s some C# code that simply calls a virtual method (named test()) from the class’ constructor:

class TestBaseClass {
  public TestBaseClass() {
    Console.Write("From base class: ");
    test();
  }

  protected virtual void test() {
    Console.WriteLine("in base class");
  }
}

Creating an instance of this class results in nothing special:

From base class: in base class

Now lets create a sub class of TestBaseClass and override the virtual method:

class TestSubClass : TestBaseClass {
  public TestSubClass() {
    Console.Write("From sub class: ");
    test();
  }

  protected override void test() {
    Console.WriteLine("in sub class");
  }
}

Now, creating an instance of TestSubClass will print this:

From base class: in sub class
From sub class: in sub class

This means that the sub class’ implementation of test() was executed (and not TestBaseClass‘ implementation) – just as expected.

Note: In Java all methods are automatically virtual. In contrast to C# or C++ you can’t create “non-virtual” methods in Java.

The C++ Problem ∞

And exactly here is the problem in C++. Let’s create a C++ version of the two classes above (compiled with Visual C++).

Header file (TestClass.h):

#pragma once

class TestBaseClass {
public:
  TestBaseClass();

protected:
  virtual void test();
};


class TestSubClass : public TestBaseClass {
public:
  TestSubClass();

protected:
  virtual void test();
};

Source file (TestClass.cpp):

#include "TestClass.h"
#include <stdio.h>

TestBaseClass::TestBaseClass() {
  printf("From base class: ");
  test();
}

void TestBaseClass::test() {
  printf("in base class\n");
}


TestSubClass::TestSubClass() : TestBaseClass() {
  printf("From sub class: ");
  test();
}

void TestSubClass::test() {
  printf("in sub class\n");
}

Now, creating an instance of TestSubClass results in the following output:

From base class: in base class
From sub class: in sub class

Note how the base class’ implementation of test() is used in the base class constructor while the sub class’ implementation of test() is used in the sub class constructor.

The problem here (in constrast to C# or Java) is that the sub class constructor hasn’t been executed yet and therefore the “redirection” from TestBaseClass::test() to TestSubClass::test() hasn’t been established yet.

Rule: There is no way to call a sub class’ implementation of a virtual function in the base class constructor!

The problem becomes even more severe with pure virtual (which is abstract in C# and Java) methods. These methods don’t even have an implementation in the base class and therefore can’t be executed at all.

For your interest: A C++/CLI class will behave like a C# class (and not like a C++ class).

Example Visual Studio Solution ∞

I’ve created a solution (for Visual Studio 2010) containing the source code above. In addition to a C# and a C++ project, I’ve also added a C++/CLI project. You can download it here:

VirtualMethodTest.zip

I love internet radio. And I love iTunes. So the next logical step would be for me to manage my favorite radio stations in iTunes – preferably in a special playlist only so that the radio stations don’t clutter up my iTunes library.

Now, iTunes comes out-of-the-box with some predefined radio stations. You can simply drag your favorite radio stations to your playlist. However, iTunes’ radio station list is far from complete. So it would be nice to be able to add new radio stations to iTunes.

The first thing you need is the URL to the live stream of the new radio station. Unfortunately, there is no way to add this URL to iTunes’ “Radio” section. Although there is the menu item “Open Stream…” (in the “Advanced” menu) that let’s you open any live stream, this live stream would be added to your iTunes library. Why is this a bad thing? Well, you can’t edit the meta data (eg. genre, title, artist, …) for live streams. If you stop a live stream and then play it again, the meta data will be reset to whatever the live stream tells iTunes. So you’ll end up with a lot genres in your genre list you don’t want to have.

The alternative is to add the live stream just to a playlist without adding it to your library. This is possible. Simply drag the live stream’s playlist file (with .pls file ending) to your iTunes playlist. This will add all entries in the playlist file to your iTunes playlist without adding them to your iTunes library. That’s it.

If you don’t have a playlist file but only the live stream’s URL, you can create a playlist file quite easily. Simply open your favorite plain text editor (note that Word will not work) and copy the following text:

[playlist]
File1=http://streamexample.com:80
Title1=My Favorite Online Radio
Length1=-1

NumberOfEntries=1

Version=2

Replace the values of File1 and Title1 with your live stream’s URL and name respectively and save the file as radio.pls. Now you can drag it to your iTunes playlist and you’re done.

Hint: You may want to activate “Repeat One” (in iTunes lower left corner) for this playlist. This prevents iTunes from going to the next radio station in the list when there is a problem with the one currently playing.

Today I did some testing on the performance of VMWare Fusion 3.1 regarding whether to use a 32-bit or a 64-bit guest system on a 64-bit host system. For the test I used:

• Machine: MacBook Pro 15” early 2010
• CPU: Intel Cor i5 2.4 GHz (Dual Core; 64-bit CPU)
• RAM: 4 GB 1067 MHz DDR3
• OS: Mac OS X 10.6.5 (with all updates)
• VMWare: VMWare Fusion 3.1.2 (332101)

For the testing I shut down all applications (that could be shut down) except for:

• VMWare Fusion (of course)
• Terminal
• TextWrangler

I also disabled Spotlight indexing for the duration of the test using (in Terminal):

$ mdutil -a -i off  # use "-i on" to reenable indexing

For testing I used an Ubuntu 10.04 Server Edition Linux either in the x86 (32-bit) and in the x64 (64-bit) version. Each version got one CPU and 512 MB RAM assigned (default values). I installed all updates (as of 2010-12-17) and also installed the packages “psmisc” and “bc”. The kernel version was 2.6.32-26. The VMWare Tools were not installed.

I then started VMWare Fusion (Virtual Machine Library only for now), and then called “purge” in the Terminal to free all inactive, unused memory for more correct information on how much memory is actually free. I then ran “vm_stat” (in Terminal), started the virtual machine, and ran “vm_stat” again to get the amount of memory actually used by the virtual machine.

Inside the virtual machine (i.e. in Ubuntu) I stopped cron and rsyslog to prevent them from interrupting the test, determined the free disk space (df -h) and the free memory (free -ok), and then calculated Pi with 3000 digits:

$ time echo "scale=3000; 4*a(1)" | (bc -l >/dev/null)

The results of the comparison can be found in the table below:

	32-bit	64-bit	Difference on 64-bit
Time to calculate Pi:	9.585s	8.823s	-7.9%
Memory consumption on the host system (MacOS):	482.3 MB	648.2 MB	+34.4%
Total/Used/Free memory in the guest system (Ubuntu):	496.96 MB / 35.22 MB / 461.74 MB	493.62 MB / 126.89 MB / 366.73 MB	+260.3% (used only)
Disk usage in the guest system (Ubuntu):	560 MB	581 MB	+3.8%

Observations:

• CPU speed: A 32-bit guest system on a 64-bit host system runs slower than a 64-bit guest system.
• Memory consumption: 64-bit guest systems require significantly more memory on the host system and on the guest system. In fact on the guest system the memory consumption seem to tripple (for some unknown reasons).
• Disk usage: As expected, disk usage is higher on a 64-bit system , but only slightly.

Conclusions: If memory consumption is an issue on your system (i.e. if you have not so much memory), then select a 32-bit guest system. It’ll be slightly slower but also consume less memory. If memory consumption is not an issue, select a 64-bit guest system.

Mir fällt gerade ein, dass ich doch noch einen Nachtrag nachreichen muss: Und zwar ist über die Weihnachtsferien (im Schweiße meines Angesichts so zu sagen) ein Artikel mit dem Titel “C# für Java-Programmierer” entstanden. Darin geht es um eine kurze Einführung in .NET und den Umstieg von Java auf C#.

Ist sicherlich für den einen oder anderen Programmierer, der früher Java programmiert hat, jetzt aber auf C# umsteigen will/muss, ganz nützlich. Der Download des Papers ist kostenlos; die Lizenz für den Artikel ist Creative Commons, und zwar:

C#-Ausarbeitung vom 27.2.2008 (732 kB)

Update: Die neue Version der Ausarbeitung vom 27. Februar 2008 ist jetzt online. Die alte Version vom 11. Dezember 2007 steht hier (703 kB) weiterhin zur Verfügung, jedoch enthält die neuere Version mehr Infos und wurde etwas gestrafft.