UnmanagedType Enumerazione

Definizione

Spazio dei nomi:

System.Runtime.InteropServices

Assembly:

System.Runtime.dll

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

public enum class UnmanagedType

public enum UnmanagedType

type UnmanagedType = 

Public Enum UnmanagedType

Ereditarietà

Object

ValueType

Enum

UnmanagedType

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 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 a interfaccia 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 per specificare la modalità di marshalling dei tipi durante l'interoperabilità UnmanagedTypeSystem.Runtime.InteropServices.MarshalAsAttribute con codice non gestito. È possibile usare questa enumerazione per eseguire il marshalling del codice usando tipi di 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.

Vedi anche

• MarshalAsAttribute
• ComImportAttribute