UnmanagedType Énumération

Définition

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

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

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. Les types ByValTStr se comportent comme des chaînes de style 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.

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.

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 le 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 la façon dont 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, R8, U2, U4 et U8), de types non managés qui ne sont pas disponibles dans le .NET Framework et de divers types divers.

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

S’applique à

Voir aussi