UnmanagedType Énumération

Définition

Espace de noms:

System.Runtime.InteropServices

Assembly:

System.Runtime.dll

Indique comment marshaler les paramètres ou les champs en code non managé.

public enum class UnmanagedType

public enum UnmanagedType

type UnmanagedType = 

Public Enum UnmanagedType

Héritage

Object

ValueType

Enum

UnmanagedType

Champs

AnsiBStr	35	Chaîne de caractères ANSI sur un octet, préfixée par sa longueur. Vous pouvez utiliser ce membre sur le type de données String.
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. Ce membre est valide pour les méthodes d'appel de plateforme uniquement.
Bool	2	Valeur booléenne sur 4 octets (true != 0, false = 0). Il s'agit du type BOOL Win32.
BStr	19	Chaîne de caractères Unicode sur deux octets, préfixée par sa longueur. Vous pouvez utiliser ce membre, qui est la chaîne par défaut dans COM, sur le type de données String.
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. Le champ ArraySubType peut éventuellement contenir le UnmanagedType des éléments du tableau, quand les types de chaîne doivent être différenciés. Vous pouvez utiliser ce UnmanagedType uniquement sur un tableau dont les éléments apparaissent sous la forme de champs dans une structure.
ByValTStr	23	Utilisé pour des tableaux de caractères de longueur fixe inline affichés dans une structure. ByValTStr Les types se comportent comme des chaînes de type C, de taille fixe à l’intérieur d’une structure (par exemple, char s[5]). Le type de caractère utilisé avec ByValTStr est déterminé par l'argument CharSet de l'attribut StructLayoutAttribute appliqué à la structure conteneur. Utilisez toujours le champ SizeConst pour indiquer la taille du tableau.
Currency	15	Type de devise. Utilisé sur un Decimal pour marshaler la valeur décimale en tant que type de devise COM, au lieu d'un Decimal.
CustomMarshaler	44	Spécifie la classe de marshaleur personnalisé dans le cas d'une utilisation avec le champ MarshalType ou MarshalTypeRef. Le champ MarshalCookie permet de passer des informations supplémentaires au marshaleur personnalisé. Vous pouvez utiliser ce membre sur n'importe quel type de référence. Ce membre est valide pour les paramètres et valeurs de retour uniquement. Il ne peut pas être utilisé sur les champs.
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.
FunctionPtr	38	Entier pouvant être utilisé comme pointeur fonction de type C. Vous pouvez utiliser ce membre sur un type de données Delegate ou sur un type qui hérite d'un Delegate.
HString	47	Chaîne Windows Runtime. Vous pouvez utiliser ce membre sur le type de données String. La prise en charge intégrée de WinRT a été supprimée dans .NET 5. Pour plus d’informations sur la solution de contournement, consultez Types pris en charge précédemment intégrés .
I1	3	Entier signé sur 1 octet. Vous pouvez utiliser ce membre pour transformer une valeur booléenne en valeur bool sur 1 octet de type C (true = 1, false = 0).
I2	5	Entier signé sur 2 octets.
I4	7	Entier signé sur 4 octets.
I8	9	Entier signé sur 8 octets.
IDispatch	26	Pointeur IDispatch COM (Object dans Microsoft Visual Basic 6.0).
IInspectable	46	Pointeur d’interface Windows Runtime. Vous pouvez utiliser ce membre sur le type de données Object. La prise en charge intégrée de WinRT a été supprimée dans .NET 5.
Interface	28	Pointeur d'interface COM. Le Guid de l'interface est obtenu à partir des métadonnées de classe. 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. Ce membre produit le même comportement que IUnknown quand vous l'appliquez au type de données Object.
IUnknown	25	Pointeur IUnknown COM. Vous pouvez utiliser ce membre sur le type de données Object.
LPArray	42	Pointeur vers le premier élément d'un tableau de style C. Lors du marshaling du code managé au code non managé, la longueur du tableau est déterminée par la longueur du tableau managé. 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.
LPStr	20	Chaîne de caractères ANSI sur un octet. Vous pouvez utiliser ce membre sur les types de données String et StringBuilder.
LPStruct	43	Pointeur vers une structure de type C que vous utilisez pour marshaler les classes mises en forme managées. Ce membre est valide pour les méthodes d'appel de plateforme uniquement.
LPTStr	22	Chaîne de caractères Unicode. 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.
LPUTF8Str	48	Pointeur vers une chaîne encodée en UTF-8.
LPWStr	21	Chaîne de caractères Unicode se terminant par null sur 2 octets. Vous ne pouvez pas utiliser la valeur LPWStr avec une chaîne non managée, sauf si la chaîne a été créée à l’aide de la fonction CoTaskMemAlloc non managée.
R4	11	Nombre à virgule flottante sur 4 octets.
R8	12	Nombre à virgule flottante sur 8 octets.
SafeArray	29	Un SafeArray est un tableau autodescriptif qui inclut le type, le rang et les limites des données de tableau associées. Vous pouvez utiliser ce membre avec le champ SafeArraySubType pour substituer le type d'élément par défaut.
Struct	27	VARIANT utilisé pour marshaler des classes et des types de valeur mis en forme managés.
SysInt	31	Entier signé qui dépend de la plateforme sur : 4 octets sous Windows 32 bits et 8 octets sous Windows 64 bits.
SysUInt	32	Entier non signé qui dépend de la plateforme sur : 4 octets sous Windows 32 bits et 8 octets sous Windows 64 bits.
TBStr	36	Chaîne Unicode char avec préfixe de longueur. Ce membre similaire à BSTR est rarement utilisé.
U1	4	Entier non signé sur 1 octet.
U2	6	Entier non signé sur 2 octets.
U4	8	Entier non signé sur 4 octets.
U8	10	Entier non signé sur 8 octets.
VariantBool	37	Type VARIANT_BOOL sur 2 octets défini par OLE (true = -1, false = 0).
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é. Cette valeur est uniquement prise en charge pour l'appel de code non managé.

Exemples

Le fragment de code suivant montre comment déclarer, dans du code source managé, une interface non managée implémentée par un composant COM. L’attribut System.Runtime.InteropServices.ComImportAttribute empêche l’exportation de l’interface IMyStorage pour une utilisation par COM. (Les clients COM doivent utiliser directement le composant COM existant.) Dans cet exemple, MarshalAsAttribute spécifie plusieurs UnmanagedType membres, qui représentent les types utilisés par l’interface COM d’origine.

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.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 l’énumération UnmanagedType avec l’attribut System.Runtime.InteropServices.MarshalAsAttribute pour spécifier comment les types sont marshalés pendant l’interopérabilité avec du code non managé. Vous pouvez utiliser cette énumération pour marshaler du code à l’aide de types valeur simples (I1, I2, I4, I8, R4, U2, U4 et U8), de types non managés qui ne sont pas disponibles dans le .NET Framework et de différents types divers.

Pour plus d’informations, consultez Interopération avec du code non managé.

Voir aussi

• MarshalAsAttribute
• ComImportAttribute