UnmanagedType UnmanagedType UnmanagedType UnmanagedType Enum

Définition

Indique comment marshaler les paramètres ou les champs en code non managé.Identifies how to marshal parameters or fields to unmanaged code.

public enum class UnmanagedType
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum UnmanagedType
type UnmanagedType = 
Public Enum UnmanagedType
Héritage
UnmanagedTypeUnmanagedTypeUnmanagedTypeUnmanagedType
Attributs

Champs

AnsiBStr AnsiBStr AnsiBStr AnsiBStr 35

Chaîne de caractères ANSI sur un octet, préfixée par sa longueur.An ANSI character string that is a length-prefixed single byte. Vous pouvez utiliser ce membre sur le type de données String.You can use this member on the String data type.

AsAny AsAny AsAny AsAny 40

Type dynamique qui détermine le type d’un objet au moment de l’exécution et marshale l’objet comme ce type.A dynamic type that determines the type of an object at run time and marshals the object as that type. Ce membre est valide pour les méthodes d'appel de plateforme uniquement.This member is valid for platform invoke methods only.

Bool Bool Bool Bool 2

Valeur booléenne sur 4 octets (true != 0, false = 0).A 4-byte Boolean value (true != 0, false = 0). Il s'agit du type BOOL Win32.This is the Win32 BOOL type.

BStr BStr BStr BStr 19

Chaîne de caractères Unicode sur deux octets, préfixée par sa longueur.A Unicode character string that is a length-prefixed double byte. Vous pouvez utiliser ce membre, qui est la chaîne par défaut dans COM, sur le type de données String.You can use this member, which is the default string in COM, on the String data type.

ByValArray ByValArray ByValArray ByValArray 30

Quand la propriété Value a la valeur ByValArray, le champ SizeConst doit être défini pour indiquer le nombre d'éléments dans le tableau.When the Value property is set to ByValArray, the SizeConst field must be set to indicate the number of elements in the array. Le champ ArraySubType peut éventuellement contenir le UnmanagedType des éléments du tableau, quand les types de chaîne doivent être différenciés.The ArraySubType field can optionally contain the UnmanagedType of the array elements when it is necessary to differentiate among string types. Vous pouvez utiliser ce UnmanagedType uniquement sur un tableau dont les éléments apparaissent sous la forme de champs dans une structure.You can use this UnmanagedType only on an array that whose elements appear as fields in a structure.

ByValTStr ByValTStr ByValTStr ByValTStr 23

Utilisé pour des tableaux de caractères de longueur fixe inline affichés dans une structure.Used for in-line, fixed-length character arrays that appear within a structure. Le type de caractère utilisé avec ByValTStr est déterminé par l'argument CharSet de l'attribut StructLayoutAttribute appliqué à la structure conteneur.The character type used with ByValTStr is determined by the CharSet argument of the StructLayoutAttribute attribute applied to the containing structure. Utilisez toujours le champ SizeConst pour indiquer la taille du tableau.Always use the SizeConst field to indicate the size of the array.

Currency Currency Currency Currency 15

Type de devise.A currency type. Utilisé sur un Decimal pour marshaler la valeur décimale en tant que type de devise COM, au lieu d'un Decimal.Used on a Decimal to marshal the decimal value as a COM currency type instead of as a Decimal.

CustomMarshaler CustomMarshaler CustomMarshaler CustomMarshaler 44

Spécifie la classe de marshaleur personnalisé dans le cas d'une utilisation avec le champ MarshalType ou MarshalTypeRef.Specifies the custom marshaler class when used with the MarshalType or MarshalTypeRef field. Le champ MarshalCookie permet de passer des informations supplémentaires au marshaleur personnalisé.The MarshalCookie field can be used to pass additional information to the custom marshaler. Vous pouvez utiliser ce membre sur n'importe quel type de référence.You can use this member on any reference type. Ce membre est valide pour les paramètres et valeurs de retour uniquement.This member is valid for parameters and return values only. Il ne peut pas être utilisé sur les champs.It cannot be used on fields.

Error Error Error Error 45

Type natif associé à I4 ou à U4 et qui entraîne l'exportation du paramètre en tant que HRESULT dans la bibliothèque de types exportée.A native type that is associated with an I4 or an U4 and that causes the parameter to be exported as an HRESULT in the exported type library.

FunctionPtr FunctionPtr FunctionPtr FunctionPtr 38

Entier pouvant être utilisé comme pointeur fonction de type C.An integer that can be used as a C-style function pointer. Vous pouvez utiliser ce membre sur un type de données Delegate ou sur un type qui hérite d'un Delegate.You can use this member on a Delegate data type or on a type that inherits from a Delegate.

HString HString HString HString 47

Chaîne Windows RuntimeWindows Runtime.A Windows RuntimeWindows Runtime string. Vous pouvez utiliser ce membre sur le type de données String.You can use this member on the String data type.

I1 I1 I1 I1 3

Entier signé sur 1 octet.A 1-byte signed integer. Vous pouvez utiliser ce membre pour transformer une valeur booléenne en valeur bool sur 1 octet de type C (true = 1, false = 0).You can use this member to transform a Boolean value into a 1-byte, C-style bool (true = 1, false = 0).

I2 I2 I2 I2 5

Entier signé sur 2 octets.A 2-byte signed integer.

I4 I4 I4 I4 7

Entier signé sur 4 octets.A 4-byte signed integer.

I8 I8 I8 I8 9

Entier signé sur 8 octets.An 8-byte signed integer.

IDispatch IDispatch IDispatch IDispatch 26

Pointeur IDispatch COM (Object dans Microsoft Visual Basic 6.0).A COM IDispatch pointer (Object in Microsoft Visual Basic 6.0).

IInspectable IInspectable IInspectable IInspectable 46

Pointeur d'interface Windows RuntimeWindows Runtime.A Windows RuntimeWindows Runtime interface pointer. Vous pouvez utiliser ce membre sur le type de données Object.You can use this member on the Object data type.

Interface Interface Interface Interface 28

Pointeur d'interface COM.A COM interface pointer. Le Guid de l'interface est obtenu à partir des métadonnées de classe.The Guid of the interface is obtained from the class metadata. Utilisez ce membre pour spécifier le type exact d'interface ou le type d'interface par défaut si vous l'appliquez à une classe.Use this member to specify the exact interface type or the default interface type if you apply it to a class. Ce membre produit le même comportement que IUnknown quand vous l'appliquez au type de données Object.This member produces the same behavior as IUnknown when you apply it to the Object data type.

IUnknown IUnknown IUnknown IUnknown 25

Pointeur IUnknown COM.A COM IUnknown pointer. Vous pouvez utiliser ce membre sur le type de données Object.You can use this member on the Object data type.

LPArray LPArray LPArray LPArray 42

Pointeur vers le premier élément d'un tableau de style C.A pointer to the first element of a C-style array. Lors du marshaling du code managé au code non managé, la longueur du tableau est déterminée par la longueur du tableau managé.When marshaling from managed to unmanaged code, the length of the array is determined by the length of the managed array. Lors du marshaling du code non managé au code managé, la longueur du tableau est déterminée par les champs SizeConst et SizeParamIndex, suivis éventuellement par le type non managé des éléments du tableau quand les types de chaîne doivent être différenciés.When marshaling from unmanaged to managed code, the length of the array is determined from the SizeConst and SizeParamIndex fields, optionally followed by the unmanaged type of the elements within the array when it is necessary to differentiate among string types.

LPStr LPStr LPStr LPStr 20

Chaîne de caractères ANSI sur un octet.A single byte, null-terminated ANSI character string. Vous pouvez utiliser ce membre sur les types de données String et StringBuilder.You can use this member on the String and StringBuilder data types.

LPStruct LPStruct LPStruct LPStruct 43

Pointeur vers une structure de type C que vous utilisez pour marshaler les classes mises en forme managées.A pointer to a C-style structure that you use to marshal managed formatted classes. Ce membre est valide pour les méthodes d'appel de plateforme uniquement.This member is valid for platform invoke methods only.

LPTStr LPTStr LPTStr LPTStr 22

Une chaîne de caractères dépendante de la plateforme : ANSI sous Windows 98 et Unicode sous Windows NT et Windows XP.A platform-dependent character string: ANSI on Windows 98, and Unicode on Windows NT and Windows XP. Cette valeur est uniquement prise en charge pour un appel de code non managé uniquement, elle ne l'est pas pour COM Interop, l'exportation d'une chaîne de type LPTStr n'étant pas prise en charge.This value is supported only for platform invoke and not for COM interop, because exporting a string of type LPTStr is not supported.

LPUTF8Str LPUTF8Str LPUTF8Str LPUTF8Str 48

Pointeur vers une chaîne encodée en UTF-8.A pointer to a UTF-8 encoded string.

LPWStr LPWStr LPWStr LPWStr 21

Chaîne de caractères Unicode se terminant par null sur 2 octets.A 2-byte, null-terminated Unicode character string.

R4 R4 R4 R4 11

Nombre à virgule flottante sur 4 octets.A 4-byte floating-point number.

R8 R8 R8 R8 12

Nombre à virgule flottante sur 8 octets.An 8-byte floating-point number.

SafeArray SafeArray SafeArray SafeArray 29

Un SafeArray est un tableau autodescriptif qui inclut le type, le rang et les limites des données de tableau associées.A SafeArray, which is a self-describing array that carries the type, rank, and bounds of the associated array data. Vous pouvez utiliser ce membre avec le champ SafeArraySubType pour substituer le type d'élément par défaut.You can use this member with the SafeArraySubType field to override the default element type.

Struct Struct Struct Struct 27

VARIANT utilisé pour marshaler des classes et des types de valeur mis en forme managés.A VARIANT, which is used to marshal managed formatted classes and value types.

SysInt SysInt SysInt SysInt 31

Un entier signé dépendant de la plateforme : 4 octets sous Windows 32 bits, 8 octets sous Windows 64 bits.A platform-dependent, signed integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

SysUInt SysUInt SysUInt SysUInt 32

Un entier non signé dépendant de la plateforme : 4 octets sous Windows 32 bits, 8 octets sous Windows 64 bits.A platform-dependent, unsigned integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

TBStr TBStr TBStr TBStr 36

Une chaîne char préfixée par sa longueur et dépendante de la plateforme : ANSI sous Windows 98, Unicode sous Windows NT.A length-prefixed, platform-dependent char string: ANSI on Windows 98, Unicode on Windows NT. Ce membre similaire à BSTR est rarement utilisé.You rarely use this BSTR-like member.

U1 U1 U1 U1 4

Entier non signé sur 1 octet.A 1-byte unsigned integer.

U2 U2 U2 U2 6

Entier non signé sur 2 octets.A 2-byte unsigned integer.

U4 U4 U4 U4 8

Entier non signé sur 4 octets.A 4-byte unsigned integer.

U8 U8 U8 U8 10

Entier non signé sur 8 octets.An 8-byte unsigned integer.

VariantBool VariantBool VariantBool VariantBool 37

Type VARIANT_BOOL sur 2 octets défini par OLE (true = -1, false = 0).A 2-byte, OLE-defined VARIANT_BOOL type (true = -1, false = 0).

VBByRefStr VBByRefStr VBByRefStr VBByRefStr 34

Valeur qui permet à Visual Basic de changer une chaîne en code non managé et de répercuter les résultats dans du code managé.A value that enables Visual Basic to change a string in unmanaged code and have the results reflected in managed code. Cette valeur est uniquement prise en charge pour l'appel de code non managé.This value is only supported for platform invoke.

Exemples

Le fragment de code suivant montre comment déclarer, dans le code source managé, une interface non managée implémentée par un composant COM.The following code fragment demonstrates how to declare, in managed source code, an unmanaged interface implemented by a COM component. Le System.Runtime.InteropServices.ComImportAttribute attribut empêche le IMyStorage interface à partir d’en cours d’exportation pour une utilisation par COM.The System.Runtime.InteropServices.ComImportAttribute attribute prevents the IMyStorage interface from being exported back for use by COM. (Les clients COM doivent utiliser le composant COM existant directement.) Dans cet exemple, MarshalAsAttribute spécifie plusieurs UnmanagedType membres, qui représentent les types utilisés par l’interface COM d’origine.(COM clients should use the existing COM component directly.) In this example, MarshalAsAttribute specifies several UnmanagedType members, which represent the types used by the original COM interface.

using namespace System;
using namespace System::Runtime::InteropServices;

// If you do not have a type library for an interface
// you can redeclare it using ComImportAttribute.
// This is how the interface would look in an idl file.
//[
//object,
//uuid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26"),
//dual, helpstring("IMyStorage Interface"),
//pointer_default(unique)
//]
//interface IMyStorage : IDispatch
//{
// [id(1)]
// HRESULT GetItem([in] BSTR bstrName, [out, retval] IDispatch ** ppItem);
// [id(2)]
// HRESULT GetItems([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT)* pItems);
// [id(3)]
// HRESULT GetItemDescriptions([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT) ** ppItems);
// [id(4), propget]
// HRESULT get_IsEmpty([out, retval] BOOL * pfEmpty);
//};
// This is the managed declaration.

[ComImport]
[Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")]
interface class IMyStorage
{
   [DispId(1)]
   Object^ GetItem( [In,MarshalAs(UnmanagedType::BStr)]String^ bstrName );

   //[return : MarshalAs(UnmanagedType::Interface)]

   [DispId(2)]
   void GetItems( [In,MarshalAs(UnmanagedType::BStr)]String^ bstrLocation, [Out,MarshalAs(UnmanagedType::SafeArray,
   SafeArraySubType=VarEnum::VT_VARIANT)]array<Object^>^Items );

   [DispId(3)]
   void GetItemDescriptions( [In]String^ bstrLocation, [In,Out,MarshalAs(UnmanagedType::SafeArray)]array<Object^>^varDescriptions );

   property bool IsEmpty 
   {
      [DispId(4)]
      [returnvalue:MarshalAs(UnmanagedType::VariantBool)]
      bool get();
   }
};
using System;
using System.Runtime.InteropServices;

namespace MyModule
{
	// If you do not have a type library for an interface
	// you can redeclare it using ComImportAttribute.

	// This is how the interface would look in an idl file.

	//[
	//object,
	//uuid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26"),
	//dual,	helpstring("IMyStorage Interface"),
	//pointer_default(unique)
	//]
	//interface IMyStorage : IDispatch
	//{
	//	[id(1)]
	//	HRESULT GetItem([in] BSTR bstrName, [out, retval] IDispatch ** ppItem);
	//	[id(2)]
	//	HRESULT GetItems([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT)* pItems);
	//	[id(3)]
	//	HRESULT GetItemDescriptions([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT) ** ppItems);
	//	[id(4), propget]
	//	HRESULT get_IsEmpty([out, retval] BOOL * pfEmpty);
	//};

	// This is the managed declaration.

	[ComImport]
	[Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")]
	public interface IMyStorage  
	{
		[DispId(1)]
		[return : MarshalAs( UnmanagedType.Interface )]
		Object GetItem( [In, MarshalAs( UnmanagedType.BStr )] String bstrName );

		[DispId(2)]
		void GetItems( [In, MarshalAs( UnmanagedType.BStr )] String bstrLocation, 
			[Out, MarshalAs( UnmanagedType.SafeArray, 
					  SafeArraySubType = VarEnum.VT_VARIANT )] out Object[] Items );
                
                
		[DispId(3)]
		void GetItemDescriptions( [In] String bstrLocation, 
			[In, Out, MarshalAs( UnmanagedType.SafeArray )] ref Object[] varDescriptions );

		bool IsEmpty 
		{
			[DispId(4)]
			[return : MarshalAs( UnmanagedType.VariantBool )]
			get;
		}
	}
}
Imports System
Imports System.Runtime.InteropServices

Module MyModule
	' If you do not have a type library for an interface
	' you can redeclare it using ComImportAttribute.

	' This is how the interface would look in an idl file.

	'[
	'object,
	'uuid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26"),
	'dual,	helpstring("IMyStorage Interface"),
	'pointer_default(unique)
	']
	'interface IMyStorage : IDispatch
	'{
	'	[id(1)]
	'	HRESULT GetItem([in] BSTR bstrName, [out, retval] IDispatch ** ppItem);
	'	[id(2)]
	'	HRESULT GetItems([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT)* pItems);
	'	[id(3)]
	'	HRESULT GetItemDescriptions([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT) ** ppItems);
	'	[id(4), propget]
	'	HRESULT get_IsEmpty([out, retval] BOOL * pfEmpty);
	'};

	' This is the managed declaration.

	<ComImport(), Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")> _
	Public Interface IMyStorage
		<DispId(1)> _
		Function GetItem(<InAttribute(), MarshalAs(UnmanagedType.BStr)> ByVal bstrName As String) _
		   As <MarshalAs(UnmanagedType.Interface)> Object

		<DispId(2)> _
		Function GetItems(<InAttribute(), MarshalAs(UnmanagedType.BStr)> ByVal bstrLocation As String, _
		   <OutAttribute(), MarshalAs(UnmanagedType.SafeArray, SafeArraySubType := VarEnum.VT_VARIANT)> _
                                      ByVal Items() As Object)

		<DispId(3)> _
		Function GetItemDescriptions(<InAttribute()> ByVal bstrLocation As String, _
		   <InAttribute(), OutAttribute(), _
                      MarshalAs(UnmanagedType.SafeArray)> ByRef varDescriptions() As Object)

		<DispId(4)> _
		ReadOnly Property IsEmpty(<MarshalAs(UnmanagedType.VariantBool)> ByVal bEmpty As Boolean)

	End Interface
End Module

Remarques

Utilisez le UnmanagedType énumération avec la System.Runtime.InteropServices.MarshalAsAttribute attribut pour spécifier comment les types sont marshalés lors de l’interopérabilité avec du code non managé.Use the UnmanagedType enumeration with the System.Runtime.InteropServices.MarshalAsAttribute attribute to specify how types are marshaled during interoperation with unmanaged code. Vous pouvez utiliser cette énumération pour marshaler à l’aide de la valeur simple types (I1, I2, I4, I8, R4, R8, U2, U4 et U8), types non managés qui ne sont pas disponibles dans le .NET Framework et divers autres types de code.You can use this enumeration to marshal code using simple value types (I1, I2, I4, I8, R4, R8, U2, U4, and U8), unmanaged types that are unavailable in the .NET Framework, and various miscellaneous types.

Pour plus d’informations, consultez Interopération avec du code non managé.For more information, see Interoperating with Unmanaged Code.

S’applique à

Voir aussi