Vue d'ensemble du marshaling

Article
08/21/2008

Mise à jour : novembre 2007

Le .NET Compact Framework version 2.0 fournit la prise en charge du marshaling développée via IDispatch et via les appels de code non managé et vtable. Cette prise en charge inclut ce qui suit :

Utilisation de l'attribut MarshalAsAttribute.
Marshaling des types variant pris en charge sous Windows Embedded CE.
Marshaling des types qui appellent les interfaces COM via un vtable.
Marshaling de structures avec des chaînes et des tableaux incorporés.
Spécification de la disposition d'une structure.

Vous pouvez marshaler les types suivants par valeur ou par référence :

BStr
IUnknown
IDispatch
SafeArray
DateTime (marshalé en tant que DATE OLE)
Variant

Notez que .NET Compact Framework 2.0 prend en charge les méthodes AllocHGlobal et FreeHGlobal.

Enregistrement d'interopérabilité

Vous pouvez créer les fichiers journaux des signatures de fonction pour savoir comment un appel Interop est marshalé. Pour plus d'informations sur la création des fichiers, consultez Comment : créer des fichiers journaux. Pour plus d'informations sur l'interprétation des fichiers journaux, consultez Informations sur le fichier journal.

Marshaling des différences avec le .NET Framework complet

Le .NET Compact Framework ne prend pas en charge les fonctionnalités de marshaling et d'interopérabilité suivantes dans le .NET Framework complet :

Marshaling personnalisé.
Obtention d'un délégué managé à partir d'un pointeur fonction natif à l'aide de la méthode GetDelegateForFunctionPointer. Toutefois, vous pouvez créer un pointeur fonction natif à partir d'un délégué managé.
Accès aux classes du .NET Compact Framework à partir de composants natifs.
Passage de structures (VT_RECORD) via IDispatch.
Passage des types Int64 et UInt64 via IDispatch.

Le .NET Compact Framework se distingue du .NET Framework complet par les comportements de marshaling suivants :

Le .NET Compact Framework autorise le marshaling des tableaux de valeurs SCODE, contrairement au .NET Framework complet.
Le .NET Compact Framework et le .NET Framework complet ne marshalent pas les tableaux de pointeurs IUnknown et IDispatch de la même manière.
Le .NET Compact Framework initialise tous les threads en tant que multithreads cloisonnés et ne prend pas en charge les autres modèles de thread ou la définition d'un modèle cloisonné. Par conséquent, le .NET Compact Framework ne prend pas en charge la propriété ApartmentState ni les méthodes suivantes :

Marshaling avec l'instruction Declare Visual Basic

L'instruction Declare Visual Basic offre une autre façon de déclarer des références à des procédures externes dans une DLL. Notez que le mot clé Ansi dans l'instruction Declare n'est pas pris en charge.

Le marshaling avec l'instruction Declare est identique au marshaling avec la classe DllImportAttribute, excepté pour les objets ByVal String. Dans une instruction Declare, un paramètre ByVal String est marshalé comme paramètre de sortie. Comme les chaînes sont immuables, le Common Language Runtime est forcé de copier la chaîne et de retourner une nouvelle référence.

Différences entre les marshaleurs d'appel de code non managé et IDispatch

Le tableau suivant répertorie les types qui sont marshalés différemment par les deux marshaleurs.

Type	IDispatch	Appel de code non managé et vtable
String	BStr	wchar *
Object	Variant	NULL
Boolean	VARIANT_BOOL	byte
Array	SafeArray	Tableau conforme au style C

Le .NET Compact Framework marshale une classe via l'appel de code non managé sans StructLayoutAttribute comme une structure de disposition automatique ; le .NET Framework complet la marshale comme un wrapper CCW (COM Callable Wrapper).

Notez que le .NET Compact Framework marque SafeArray avec FADF_FIXEDSIZE et lève une exception si vous le redimensionnez en code natif.

Si Boolean est converti en type d'octet natif, vous ne pouvez marshaler Boolean qu'en tant qu'argument, et non pas comme un type de retour.

Marshaling des délégués

Par défaut, les délégués sont marshalés en tant que pointeurs fonction. Vous pouvez également utiliser explicitement la valeur FunctionPtr de l'énumération UnmanagedType pour créer une instance de MarshalAsAttribute. Consultez Marshaling de délégués comme pointeurs fonction pour obtenir des exemples.

Spécification d'un jeu de caractères

Vous pouvez utiliser le champ CharSet de DllImportAttribute pour spécifier un jeu de caractères lors du marshaling de chaînes via l'appel de code non managé.

Le .NET Compact Framework prend en charge les deux valeurs suivantes :

Auto. Les chaînes sont marshalées à l'aide du jeu de caractères approprié au système d'exploitation, à savoir le jeu de caractères Unicode. Valeur par défaut.
Unicode. Les chaînes sont marshalées à l'aide du jeu de caractères Unicode.

La valeur Ansi n'est pas prise en charge, car Windows Embedded CE n'accepte que le format Unicode. None équivaut à Ansi et n'est pas pris en charge.

Comme le .NET Compact Framework ne prend pas en charge le champ ExactSpelling, le Common Language Runtime recherche automatiquement un point d'entrée conformément aux valeurs spécifiées par CharSet.

Épinglage d'objets

Lorsque le Common Language Runtime du .NET Compact Framework marshale un objet, celui-ci est épinglé pendant toute la durée de l'appel de code non managé pour éviter qu'il ne soit libéré ou déplacé par le garbage collector.

Utilisation de la mémoire

Respectez les instructions suivantes pour gérer la mémoire avec un code non managé dans le .NET Compact Framework :

Allouez toujours de la mémoire en code managé avant de la passer au code non managé.
Si le code non managé contient un pointeur vers un composant managé, vous devez épingler l'objet manuellement à l'aide de la structure GCHandle.

Le Common Language Runtime du .NET Compact Framework participe à l'initialisation des threads (CoInitialize) au moment du démarrage et à leur désinitialisation (CoUninitialize) au moment de l'arrêt. Les threads sont marqués comme conformes au « modèle de thread libre ».

Voir aussi

Share via