Unions mit C# übergeben
Die Welt von C/C++ ist schon eine Herausforderung für sich. Besonders wenn man versucht APIs aus C# aufzurufen. Unterschiedliche Aufrufkonventionen gilt es zu dekorieren und entsprechend Daten zu übertragen. Marshaling ist hier das Stichwort. Bei meinem letzten TechTalk fragte mich ein Teilnehmer gerade hierzu. Er möchte eine API aus C# Aufrufen die als Übergabeparameter eine Struktur mit Unions enthält.
Wow, nicht einfach. Ein kleines Beispiel mit folgenden Strukturen in C++:
typedef struct struct1
{
short year;
short month;
short day;
} Struct1;
typedef struct struct2
{
char numberOfCalls[ 30 ];
} Struct2;
typedef struct struct3
{
int whatever;
union
{
Struct1 member1;
Struct2 member2;
} content;
} Struct3;
Struct3 enthält entweder Struct1 oder Struct2. Die Anwendung prüft in der Funktion DoSomething() auf das Feld whatever und entscheided dann, welche Union in der Struktur verwendet wird.
void DoSomething( Struct3 data )
{
if( data.whatever == 1 )
{
std::cout << "Struct1 content" << std::endl;
std::cout << data.content.member1.year
<< "/" << data.content.member1.month
<< "/" << data.content.member1.day << std::endl;
}
else
{
std::cout << "Struct2 content" << std::endl;
std::cout << data.content.member2.numberOfCalls << std::endl;
}
}
Exportiert man nun diese Strukturen und die Funktion mittels __declspec(dllExport) kann man das ganze aus einem C++ Client nutzen.
Struct3 test1;
test1.whatever = 1;
test1.content.member1.year = 2007;
test1.content.member1.month = 11;
test1.content.member1.day = 27;
DoSomething( test1 );
std::memset( &test1, 0, sizeof( Struct3 ) );
test1.whatever = 2;
memcpy_s( &test1.content.member2.numberOfCalls, 30, "12345", 5 );
DoSomething( test1 );
(Man verzeihe mir an dieser Stelle das memcpy_s!)
Welche Möglichkeiten gäbe es nun das ganze aus C# heraus zu nutzen? Nun zum einen könnte man einen entsprechenden C++/CLI Wrapper bauen und das ganze dementsprechend als eigenen .NET Typ zur Verfügung stellen. Zum anderen gibt es ja noch die Möglichkeit das ganze per P/Invoke zu adressieren.
Ich selbst bevorzuge nicht den Weg per P/Invoke, allerdings verstehe ich das es manchmal einfacher ist, kurz etwas zu deklarieren, anstatt ein seperates C++/CLI Projekt zu pflegen.
Gut, die Wahl ist auf P/Invoke gefallen. Das Attribut DllImportAttribute ist nun die Deklarationsschnittstelle zwischen C# und C++. Hier passiert die ganze Magie zur Laufzeit. Das einzige was man tun muss, ist der CLR Hinweise geben, wie das ganze von Managed nach Unmanaged transferiert werden soll.
Bei einer Union wäre eine Möglichkeit, redundante Deklarationen für die unterschiedlichen Union Member. Hier der Code um das zu veranschaulichen:
[StructLayout( LayoutKind.Sequential )]
public struct Struct1
{
public short year;
public short month;
public short day;
}
public struct Struct2
{
[MarshalAs(UnmanagedType.ByValTStr,SizeConst=30)]
public string numberOfCalls;
}
[StructLayout( LayoutKind.Sequential )]
public struct Struct3a
{
public int whatever;
[MarshalAs( UnmanagedType.Struct )]
public Struct1 content;
}
[StructLayout( LayoutKind.Sequential )]
public struct Struct3b
{
public int whatever;
[MarshalAs( UnmanagedType.Struct )]
public Struct2 content;
}
public class UnionLib
{
[DllImport( @"UnionSample.dll", EntryPoint = "#1" )]
public extern static void DoSomething(
[MarshalAs( UnmanagedType.Struct )] Struct3a data );
[DllImport( @"UnionSample.dll", EntryPoint = "#1" )]
public extern static void DoSomething(
[MarshalAs( UnmanagedType.Struct )] Struct3b data );
}
Für jede Union Variation gibt es nun eine eigene Struktur mit exakten Marshaling Anweisungen. Zu dem gibt es die Funktion DoSomething() mit zwei unterschiedlichen Aufrufkonventionen für die entsprechenden Strukturen.
Nun lässt sich auch die Funktionalität einfach aus C# programmieren:
Struct3a s = new Struct3a();
s.whatever = 1;
s.content.year = 2007;
s.content.month = 11;
s.content.day = 27;
UnionLib.DoSomething( s );
Struct3b s2 = new Struct3b();
s2.whatever = 2;
s2.content.numberOfCalls = "Hallo";
UnionLib.DoSomething( s2 );
Das Aufwendigste an der Sache ist wirklich die Definition der einzelnen Interop-Anweisungen. Wenn es sich nur um ein paar Methoden und Strukturen handelt ist dieser Aufwand vertretbar. Es ist auch denkbar sich ein Tool zu schreiben, das die entsprechenden Anweisungen generiert (vielleicht gibt es auch schon ein solches?), doch hierbei sollte man nochmals explizit einen Blick auf die zu erwartenden Daten werfen.
Die Mächtigkeit von P/Invoke ist die deklarative Art, die zur Laufzeit evaluiert wird. Ein Problem ist immer, eine Funktion ansprechen zu müssen, die nicht im Source verfügbar ist, schlecht dokumentiert und unter Umständen einfach einen VOID Pointer erwartet. Kurz, ein schwarzes Loch das alles mögliche an Fehlern verursachen kann. Hier ist sorgfältiges Testen angesagt bevor das ganze in Produktion geht (Unter uns, das ist doch eine Selbstverständlichkeit, oder?).