UnmanagedType Enumerazione

Definizione

Identifica come eseguire il marshalling di parametri o campi nel codice gestito.

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
Ereditarietà
UnmanagedType
Attributi

Campi

AnsiBStr 35

Stringa di caratteri ANSI costituita da un singolo byte con prefisso di lunghezza. È possibile usare questo membro nel tipo di dati String.

AsAny 40

Tipo dinamico che determina il tipo di un oggetto in fase di esecuzione ed effettua il marshalling dell'oggetto come quel tipo. Questo membro è valido solo per metodi di platform invoke.

Bool 2

Valore booleano a 4 byte (true != 0, false = 0). Si tratta del tipo BOOL Win32.

BStr 19

Stringa di caratteri Unicode costituita da un byte doppio con prefisso di lunghezza. È possibile usare questo membro, ovvero la stringa predefinita in COM, nel tipo di dati String.

ByValArray 30

Quando la proprietà Value è impostata su ByValArray, il campo SizeConst deve essere impostato per indicare il numero di elementi nella matrice. Il campo ArraySubType può contenere facoltativamente l'oggetto UnmanagedType degli elementi della matrice quando è necessario distinguere tra più tipi di stringa. È possibile usare solo questo oggetto UnmanagedType in una matrice i cui elementi vengono visualizzati come campi in una struttura.

ByValTStr 23

Usato per matrici di caratteri di lunghezza fissa inline visualizzate all'interno di una struttura. ByValTStr i tipi si comportano come stringhe di tipo C, a dimensione fissa all'interno di una struttura , ad esempio char s[5]. Il tipo di carattere usato con ByValTStr è determinato dall'argomento CharSet dell'attributo StructLayoutAttribute applicato alla struttura che lo contiene. Usare sempre il campo SizeConst per indicare le dimensioni della matrice.

Currency 15

Tipo di valuta. Usato su un oggetto Decimal per effettuare il marshalling del valore decimale come tipo di valuta COM anziché come Decimal.

CustomMarshaler 44

Specifica la classe del gestore di marshalling personalizzato quando è usato con il campo MarshalType o MarshalTypeRef. È possibile usare il campo MarshalCookie per passare informazioni aggiuntive al gestore di marshalling personalizzato. È possibile usare questo membro su qualsiasi tipo di riferimento. Questo membro è valido solo per i parametri e i valori restituiti. Non può essere usato nei campi.

Error 45

Tipo nativo associato a I4 o a U4 e che determina l'esportazione del parametro come HRESULT nella libreria dei tipi esportata.

FunctionPtr 38

Intero che può essere usato come puntatore a funzione di tipo C. È possibile usare questo membro in un tipo di dati Delegate o in un tipo che eredita da Delegate.

HString 47

Stringa di Windows Runtime. È possibile usare questo membro nel tipo di dati String. Il supporto predefinito per WinRT è stato rimosso in .NET 5. Per una soluzione alternativa, vedere Tipi supportati in precedenza predefiniti.

I1 3

Intero con segno a 1 byte. È possibile usare questo membro per trasformare un valore booleano in un valore bool a 1 byte di tipo C (true = 1, false = 0).

I2 5

Intero con segno a 2 byte.

I4 7

Intero con segno a 4 byte.

I8 9

Intero con segno a 8 byte.

IDispatch 26

Puntatore a IDispatch COM (Object in Microsoft Visual Basic 6.0).

IInspectable 46

Puntatore all'interfaccia di Windows Runtime. È possibile usare questo membro nel tipo di dati Object. Il supporto predefinito per WinRT è stato rimosso in .NET 5.

Interface 28

Puntatore a interfaccia COM. L'oggetto Guid dell'interfaccia è ottenuto dai metadati della classe. Usare questo membro per specificare il tipo di interfaccia esatto o il tipo di interfaccia predefinito se lo si applica a una classe. Questo membro produce lo stesso comportamento di IUnknown quando lo si applica al tipo di dati Object.

IUnknown 25

Puntatore a IUnknown COM. È possibile usare questo membro nel tipo di dati Object.

LPArray 42

Puntatore al primo elemento di una matrice di tipo C. Quando si effettua il marshalling da codice gestito a non gestito, la lunghezza della matrice dipende dalla lunghezza della matrice gestita. Quando si effettua il marshalling da codice non gestito a gestito, la lunghezza della matrice dipende dai campi SizeConst e SizeParamIndex, facoltativamente seguiti dal tipo non gestito degli elementi all'interno della matrice quando è necessario distinguere tra più tipi di stringa.

LPStr 20

Stringa di caratteri ANSI a un byte a terminazione Null. È possibile usare questo membro nei tipi di dati String e StringBuilder.

LPStruct 43

Puntatore a una struttura di tipo C usata per effettuare il marshalling di classi formattate gestite. Questo membro è valido solo per metodi di platform invoke.

LPTStr 22

Stringa di caratteri Unicode. Questo valore è supportato solo per platform invoke, non per l'interoperabilità COM, perché l'esportazione di una stringa di tipo LPTStr non è supportata.

LPUTF8Str 48

Puntatore a una stringa con codifica UTF-8.

LPWStr 21

Stringa di caratteri Unicode a 2 byte a terminazione Null. Non è possibile usare il valore LPWStr con una stringa non gestita, a meno che la stringa non sia stata creata tramite la funzione CoTaskMemAlloc non gestita.

R4 11

Numero a virgola mobile a 4 byte.

R8 12

Numero a virgola mobile a 8 byte.

SafeArray 29

SafeArray è una matrice autodescrittiva che contiene il tipo, la dimensione e i limiti dei dati della matrice associati. È possibile usare questo membro con il campo SafeArraySubType per eseguire l'override del tipo di elemento predefinito.

Struct 27

VARIANT usato per effettuare il marshalling di tipi valore e classi formattate gestite.

SysInt 31

Intero con segno dipendente dalla piattaforma: a 4 byte in Windows a 32 bit, a 8 byte in Windows a 64 bit.

SysUInt 32

Intero senza segno dipendente dalla piattaforma: a 4 byte in Windows a 32 bit, a 8 byte in Windows a 64 bit.

TBStr 36

Stringa Unicode char con prefisso di lunghezza. Questo membro simile a BSTR viene usato raramente.

U1 4

Intero senza segno a 1 byte.

U2 6

Intero senza segno a 2 byte.

U4 8

Intero senza segno a 4 byte.

U8 10

Intero senza segno a 8 byte.

VariantBool 37

Tipo VARIANT_BOOL definito da OLE a 2 byte (true = -1, false = 0).

VBByRefStr 34

Valore che consente a Visual Basic di modificare una stringa in codice non gestito e riflettere i risultati in codice gestito. Questo valore è supportato solo per platform invoke.

Esempio

Il frammento di codice seguente illustra come dichiarare, nel codice sorgente gestito, un'interfaccia non gestita implementata da un componente COM. L'attributo System.Runtime.InteropServices.ComImportAttribute impedisce l'esportazione dell'interfaccia IMyStorage per l'uso da parte di COM. I client COM devono usare direttamente il componente COM esistente. In questo esempio vengono MarshalAsAttribute specificati diversi UnmanagedType membri, che rappresentano i tipi utilizzati dall'interfaccia COM originale.

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

Commenti

Usare l'enumerazione con l'attributo UnmanagedTypeSystem.Runtime.InteropServices.MarshalAsAttribute per specificare la modalità di marshalling dei tipi durante l'interoperabilità con codice non gestito. È possibile usare questa enumerazione per effettuare il marshalling del codice usando tipi valore semplici (I1, I2, I4, I8, R4, R8, U2, U4 e U8), tipi non gestiti non disponibili in .NET Framework e vari tipi diversi.

Per altre informazioni, vedere Interoperabilità con codice non gestito.

Si applica a

Vedi anche