OutArrayOfStructs-Beispiel
Aktualisiert: November 2007
Dieses Beispiel zeigt die Übergabe eines Arrays von Strukturen, das Ganzzahlen und Zeichenfolgen enthält, als Out-Parameter an eine nicht verwaltete Funktion. Der Beispielquellcode ist im Technologiebeispiel für Plattformaufrufe enthalten.
Dieses Beispiel zeigt, wie eine systemeigene Funktion mithilfe der Marshal-Klasse und durch Verwenden von unsicherem Code aufgerufen wird.
In diesem Beispiel werden Wrapperfunktionen und Plattformaufrufe verwendet, die in PinvokeLib.dll definiert sind (ebenfalls in den Quelldateien bereitgestellt). Hier werden die TestOutArrayOfStructs-Funktion und die MYSTRSTRUCT2-Struktur verwendet. Diese Struktur enthält die folgenden Elemente:
typedef struct _MYSTRSTRUCT2
{
char* buffer;
UINT size;
} MYSTRSTRUCT2;
Die MyStruct-Klasse enthält ein Zeichenfolgenobjekt aus ANSI-Zeichen. Das CharSet-Feld gibt das ANSI-Format an. MyUnsafeStruct ist eine Struktur, die einen IntPtr-Typ statt einer Zeichenfolge enthält.
Die LibWrap-Klasse enthält die überladene TestOutArrayOfStructs-Prototypmethode. Wenn eine Methode einen Zeiger als Parameter deklariert, sollte die Klasse mit dem unsafe-Schlüsselwort gekennzeichnet werden. Da Visual Basic 2005 keinen unsicheren Code verwenden kann, werden die überladene Methode, der unsichere Modifizierer und die MyUnsafeStruct-Struktur nicht benötigt.
Die App-Klasse implementiert die UsingMarshal-Methode, die alle Aufgaben ausführt, welche zum Übergeben des Arrays erforderlich sind. Das Array wird mit dem out-Schlüsselwort (in Visual Basic ByRef) gekennzeichnet, um anzuzeigen, dass Daten vom Aufgerufenen an den Aufrufer übergeben werden. Die Implementierung verwendet die folgenden Marshal-Klassenmethoden:
PtrToStructure, um Daten vom nicht verwalteten Puffer an ein verwaltetes Objekt zu marshallen.
DestroyStructure, um den für Zeichenfolgen in der Struktur reservierten Speicher freizugeben.
FreeCoTaskMem, um den für das Array reservierten Speicher freizugeben.
Wie zuvor bereits erwähnt, ist unsicherer Code in C# zulässig, in Visual Basic 2005 hingegen nicht. Im C#-Beispiel ist UsingUnsafe eine alternative Methodenimplementierung, die anstelle der Marshal-Klasse Zeiger verwendet, um das Array, das die unsichere MyUnsafeStruct-Struktur enthält, zurückzugeben.
Deklarieren von Prototypen
' Declares a class member for each structure element.
< StructLayout( LayoutKind.Sequential, CharSet:=CharSet.Ansi )> _
Public Class MyStruct
Public buffer As String
Public someSize As Integer
End Class 'MyStruct
Public Class LibWrap
' Declares a managed prototype for the unmanaged function.
Declare Sub TestOutArrayOfStructs Lib "..\\LIB\\PinvokeLib.dll" ( _
ByRef arrSize As Integer, ByRef outArray As IntPtr )
End Class 'LibWrap
// Declares a class member for each structure element.
[ StructLayout( LayoutKind.Sequential, CharSet=CharSet.Ansi )]
public class MyStruct
{
public String buffer;
public int size;
}
// Declares a structure with a pointer.
[ StructLayout( LayoutKind.Sequential )]
public struct MyUnsafeStruct
{
public IntPtr buffer;
public int size;
}
public unsafe class LibWrap
{
// Declares managed prototypes for the unmanaged function.
[ DllImport( "..\\LIB\\PinvokeLib.dll" )]
public static extern void TestOutArrayOfStructs( out int size,
out IntPtr outArray );
[ DllImport( "..\\LIB\\PinvokeLib.dll" )]
public static extern void TestOutArrayOfStructs( out int size,
MyUnsafeStruct** outArray );
}
Aufrufen von Funktionen
Public Class App
Public Shared Sub Main()
Console.WriteLine( ControlChars.CrLf & "Using marshal class" & _
ControlChars.CrLf )
UsingMarshal()
'Visual Basic 2005 cannot use unsafe code.
End Sub 'Main
Public Shared Sub UsingMarshal()
Dim arrSize As Integer
Dim outArray As IntPtr
LibWrap.TestOutArrayOfStructs( arrSize, outArray )
Dim manArray(arrSize - 1) As MyStruct
Dim current As IntPtr = outArray
Dim i As Integer
For i = 0 To arrSize - 1
manArray(i) = New MyStruct()
Marshal.PtrToStructure( current, manArray(i))
Marshal.DestroyStructure( current, GetType( MyStruct ))
current = IntPtr.op_explicit( current.ToInt64() _
+ Marshal.SizeOf( manArray(i) ))
Console.WriteLine( "Element {0}: {1} {2}", i, manArray(i)._
buffer, manArray(i).someSize )
Next i
Marshal.FreeCoTaskMem( outArray )
End Sub 'UsingMarshal
End Class 'App
public class App
{
public static void Main()
{
Console.WriteLine( "\nUsing marshal class\n" );
UsingMarshal();
Console.WriteLine( "\nUsing unsafe code\n" );
UsingUnsafe();
}
public static void UsingMarshal()
{
int size;
IntPtr outArray;
LibWrap.TestOutArrayOfStructs( out size, out outArray );
MyStruct[] manArray = new MyStruct[ size ];
IntPtr current = outArray;
for( int i = 0; i < size; i++ )
{
manArray[ i ] = new MyStruct();
Marshal.PtrToStructure( current, manArray[ i ]);
//Marshal.FreeCoTaskMem( (IntPtr)Marshal.ReadInt32( current ));
Marshal.DestroyStructure( current, typeof(MyStruct) );
current = (IntPtr)((long)current +
Marshal.SizeOf( manArray[ i ] ));
Console.WriteLine( "Element {0}: {1} {2}", i,
manArray[ i ].buffer, manArray[ i ].size );
}
Marshal.FreeCoTaskMem( outArray );
}
public static unsafe void UsingUnsafe()
{
int size;
MyUnsafeStruct* pResult;
LibWrap.TestOutArrayOfStructs( out size, &pResult );
MyUnsafeStruct* pCurrent = pResult;
for( int i = 0; i < size; i++, pCurrent++ )
{
Console.WriteLine( "Element {0}: {1} {2}", i,
Marshal.PtrToStringAnsi( pCurrent->buffer ), pCurrent->size );
Marshal.FreeCoTaskMem( pCurrent->buffer );
}
Marshal.FreeCoTaskMem( (IntPtr)pResult );
}
}
Siehe auch
Konzepte
Marshallen von Klassen, Strukturen und Unions