UnmanagedType Enumeração

Definição

Namespace:

System.Runtime.InteropServices

Assembly:

System.Runtime.dll

Identifica como realizar marshaling de parâmetros ou campos para código não gerenciado.

public enum class UnmanagedType

public enum UnmanagedType

type UnmanagedType = 

Public Enum UnmanagedType

Herança

Object

ValueType

Enum

UnmanagedType

Campos

AnsiBStr	35	Uma cadeia de caracteres ANSI que é um byte único com tamanho prefixado. Use esse membro no tipo de dados String.
AsAny	40	Um tipo dinâmico que determina o tipo de um objeto em tempo de execução e realiza marshaling do objeto como esse tipo. Esse membro é válido apenas para métodos de invocação de plataforma.
Bool	2	Um valor booliano de quatro bytes (true != 0, false = 0). Esse é o tipo BOOL Win32.
BStr	19	Uma cadeia de caracteres Unicode que é um byte duplo com tamanho prefixado. Use esse membro, que é a cadeia de caracteres padrão em COM, no tipo de dados String.
ByValArray	30	Quando a propriedade Value estiver definida como ByValArray, o campo SizeConst deve ser definido para indicar o número de elementos na matriz. O campo ArraySubType pode conter, opcionalmente, o UnmanagedType dos elementos da matriz quando for necessário diferenciar entre os tipos de cadeia de caracteres. Use esse UnmanagedType somente em uma matriz cujos elementos aparecem como campos em uma estrutura.
ByValTStr	23	Usado para matrizes de caracteres em linha e de comprimento fixo que aparecem em uma estrutura. ByValTStr os tipos se comportam como cadeias de caracteres de tamanho fixo no estilo C dentro de uma estrutura (por exemplo, char s[5]). O tipo de caractere usado com ByValTStr é determinado pelo argumento CharSet do atributo StructLayoutAttribute aplicado à estrutura contida. Sempre use o campo SizeConst para indicar o tamanho da matriz.
Currency	15	Um tipo de moeda. Usado em um Decimal para realizar marshaling do valor decimal como um tipo de moeda COM em vez de como um Decimal.
CustomMarshaler	44	Especifica a classe do realizador de marshaling personalizado quando usado com o campo MarshalType ou MarshalTypeRef. O campo MarshalCookie pode ser usado para passar informações adicionais para o realizador de marshaling personalizado. Você pode usar esse membro em qualquer tipo de referência. Esse membro é válido somente para parâmetros e valores retornado. Ele não pode ser usado em campos.
Error	45	Um tipo nativo associado a um I4 ou a um U4, e que faz com que o parâmetro seja exportado como um HRESULT na biblioteca de tipos exportada.
FunctionPtr	38	Um inteiro que pode ser usado como um ponteiro de função de estilo C. Use esse membro em um tipo de dados Delegate ou em um tipo que herda de um Delegate.
HString	47	Uma cadeia de caracteres do Windows Runtime. Use esse membro no tipo de dados String. O suporte interno para WinRT foi removido no .NET 5. Consulte Tipos anteriormente integrados com suporte para obter uma solução alternativa.
I1	3	Um inteiro de um byte com sinal. Use esse membro para transformar um valor booliano em um byte, estilo C bool (true = 1, false = 0).
I2	5	Um inteiro de dois bytes com sinal.
I4	7	Um inteiro de quatro bytes com sinal.
I8	9	Um inteiro de oito bytes com sinal.
IDispatch	26	Um ponteiro COM IDispatch (Object no Microsoft Visual Basic 6.0).
IInspectable	46	Um ponteiro de interface do Windows Runtime. Use esse membro no tipo de dados Object. O suporte interno para WinRT foi removido no .NET 5.
Interface	28	Um ponteiro de interface COM. O Guid da interface é obtido dos metadados da classe. Use este membro para especificar o tipo exato de interface ou o tipo de interface padrão se você aplicá-lo a uma classe. Esse membro produz o mesmo comportamento que IUnknown quando você o aplica ao tipo de dados Object.
IUnknown	25	Um ponteiro COM IUnknown. Use esse membro no tipo de dados Object.
LPArray	42	Um ponteiro para o primeiro elemento da matriz de estilo C. Ao realizar marshaling do código gerenciado para código não gerenciado, o comprimento da matriz é determinado pelo comprimento da matriz gerenciado. Ao realizar o marshaling do código não gerenciado para o código gerenciado, o tamanho da matriz é determinado pelos campos SizeConst e SizeParamIndex, seguidos opcionalmente pelo tipo não gerenciado dos elementos dentro da matriz quando é necessário diferenciar entre os tipos de cadeia de caracteres.
LPStr	20	Uma cadeia de caracteres ANSI terminada em nulo e byte único. Use esse membro nos tipos de dados String e StringBuilder.
LPStruct	43	Um ponteiro para uma estrutura de estilo C que você usa para realizar marshaling de classes formatadas gerenciadas. Esse membro é válido apenas para métodos de invocação de plataforma.
LPTStr	22	Uma cadeia de caracteres Unicode. Esse valor tem suporte apenas para invocação de plataforma e não para interoperabilidade COM, pois não há suporte para a exportação de uma cadeia de caracteres do tipo LPTStr.
LPUTF8Str	48	Um ponteiro para uma cadeia de caracteres codificada em UTF-8.
LPWStr	21	Uma cadeia de caracteres ANSI terminada em nulo e dois bytes. Não é possível usar o valor LPWStr com uma cadeia de caracteres não gerenciada, a menos que a cadeia de caracteres tenha sido criada usando a função CoTaskMemAlloc não gerenciada.
R4	11	Um número de ponto flutuante de quatro bytes.
R8	12	Um número de ponto flutuante de oito bytes.
SafeArray	29	Um SafeArray, que é uma matriz autodescritiva que leva o tipo, a classificação e os limites dos dados de matriz associada. Usar esse membro com o campo SafeArraySubType para substituir o tipo de elemento padrão.
Struct	27	Uma VARIANTE, que é usada para realizar marshaling em classes formatadas gerenciadas e tipos de valor.
SysInt	31	Um inteiro assinado dependente de plataforma: quatro bytes no Windows de 32 bits, oito bytes no Windows de 64 bits.
SysUInt	32	Um inteiro não assinado dependente de plataforma: quatro bytes no Windows de 32 bits, oito bytes no Windows de 64 bits.
TBStr	36	Uma cadeia de caracteres Unicode char com prefixo de comprimento. Você usa raramente esse membro semelhante a BSTR.
U1	4	Um inteiro de um byte sem sinal.
U2	6	Um inteiro de dois bytes sem sinal.
U4	8	Um inteiro de quatro bytes sem sinal.
U8	10	Um inteiro de oito bytes sem sinal.
VariantBool	37	Um tipo VARIANT_BOOL de dois bytes e definido por OLE (true = -1, false = 0).
VBByRefStr	34	Um valor que permite que o Visual Basic altere uma cadeia de caracteres no código não gerenciado e reflita os resultados no código gerenciado. Esse valor só tem suporte para invocação de plataforma.

Exemplos

O fragmento de código a seguir demonstra como declarar, no código-fonte gerenciado, uma interface não gerenciada implementada por um componente COM. O System.Runtime.InteropServices.ComImportAttribute atributo impede que a IMyStorage interface seja exportada novamente para uso pelo COM. (Os clientes COM devem usar o componente COM existente diretamente.) Neste exemplo, MarshalAsAttribute especifica vários UnmanagedType membros, que representam os tipos usados pela interface COM original.

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

Comentários

Use a UnmanagedType enumeração com o System.Runtime.InteropServices.MarshalAsAttribute atributo para especificar como os tipos são empacotados durante a interoperação com código não gerenciado. Você pode usar essa enumeração para realizar marshaling de código usando tipos de valor simples (I1, I2, I4, I8, R4, R8, U2, U4 e U8), tipos não gerenciados que não estão disponíveis no .NET Framework e vários tipos diversos.

Para mais informações, confira Interoperar com código não gerenciado.

Confira também

• MarshalAsAttribute
• ComImportAttribute