Enumeração UnmanagedType

Artigo
04/23/2018

Observação

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

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

Namespace: System.Runtime.InteropServices
Assembly: mscorlib (em mscorlib.dll)

Sintaxe

[SerializableAttribute]
[ComVisibleAttribute(true)]
public enum UnmanagedType

[SerializableAttribute]
[ComVisibleAttribute(true)]
public enum class UnmanagedType

[<SerializableAttribute>]
[<ComVisibleAttribute(true)>]
type UnmanagedType

<SerializableAttribute>
<ComVisibleAttribute(True)>
Public Enumeration UnmanagedType

Membros

	Nome do membro	Descrição
	AnsiBStr	Uma cadeia de caracteres ANSI que é um byte único com tamanho prefixado. Use esse membro no tipo de dados String.
	AsAny	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	Um valor booliano de quatro bytes (true != 0, false = 0). Esse é o tipo BOOL Win32.
	BStr	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	Quando a propriedade MarshalAsAttribute.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	Usado para matrizes de caracteres em linha e de comprimento fixo que aparecem em uma estrutura. O tipo de caractere usado com ByValTStr é determinado pelo argumento System.Runtime.InteropServices.CharSet do atributo System.Runtime.InteropServices.StructLayoutAttribute aplicado à estrutura contida. Sempre use o campo MarshalAsAttribute.SizeConst para indicar o tamanho da matriz.
	Currency	Um tipo de moeda. Usado em um System.Decimal para realizar marshaling do valor decimal como um tipo de moeda COM em vez de como um Decimal.
	CustomMarshaler	Especifica a classe do realizador de marshaling personalizado quando usado com o campo MarshalAsAttribute.MarshalType ou MarshalAsAttribute.MarshalTypeRef. O campo MarshalAsAttribute.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.
	Error	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	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	Uma cadeia de caracteres Tempo de Execução do Windows. Use esse membro no tipo de dados System.String.
	I1	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	Um inteiro de dois bytes com sinal.
	I4	Um inteiro de quatro bytes com sinal.
	I8	Um inteiro de oito bytes com sinal.
	IDispatch	Um ponteiro COM IDispatch (Object no Microsoft Visual Basic 6.0).
	IInspectable	Um ponteiro de interface Tempo de Execução do Windows. Use esse membro no tipo de dados Object.
	Interface	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 UnmanagedType.IUnknown quando você o aplica ao tipo de dados Object.
	IUnknown	Um ponteiro COM IUnknown. Use esse membro no tipo de dados Object.
	LPArray	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 MarshalAsAttribute.SizeConst e MarshalAsAttribute.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	Uma cadeia de caracteres ANSI terminada em nulo e byte único. Use esse membro nos tipos de dados System.String e System.Text.StringBuilder.
	LPStruct	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	Uma cadeia de caracteres dependente de plataforma: ANSI no Windows 98 e Unicode no Windows NT e Windows XP. 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	Um ponteiro para uma cadeia de caracteres codificada em UTF-8.
	LPWStr	Uma cadeia de caracteres ANSI terminada em nulo e dois bytes.
	R4	Um número de ponto flutuante de quatro bytes.
	R8	Um número de ponto flutuante de oito bytes.
	SafeArray	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 MarshalAsAttribute.SafeArraySubType para substituir o tipo de elemento padrão.
	Struct	Uma VARIANTE, que é usada para realizar marshaling em classes formatadas gerenciadas e tipos de valor.
	SysInt	Um inteiro assinado dependente de plataforma: quatro bytes no Windows de 32 bits, oito bytes no Windows de 64 bits.
	SysUInt	Um inteiro não assinado dependente de plataforma: quatro bytes no Windows de 32 bits, oito bytes no Windows de 64 bits.
	TBStr	Uma cadeia de caracteres dependente de plataforma e de tamanho prefixado, char: ANSI no Windows 98, Unicode no Windows NT. Você usa raramente esse membro semelhante a BSTR.
	U1	Um inteiro de um byte sem sinal.
	U2	Um inteiro de dois bytes sem sinal.
	U4	Um inteiro de quatro bytes sem sinal.
	U8	Um inteiro de oito bytes sem sinal.
	VariantBool	Um tipo VARIANT_BOOL de dois bytes e definido por OLE (true = -1, false = 0).
	VBByRefStr	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.

Comentários

Use o 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 empacotar o uso de tipos de tipos (I1, I2, I4, I8, R4, R8, U2, U4 e U8), não gerenciados de valor simples que não estão disponíveis no .NET Framework e diversos tipos de código.

Para obter mais informações, consulte Interoperação com código não gerenciado.

Exemplos

O fragmento de código a seguir demonstra como declarar, em código gerenciado, uma interface não gerenciada implementada por um componente COM. O System.Runtime.InteropServices.ComImportAttribute atributo impede que o IMyStorage interface seja exportado para uso por COM. (COM os clientes 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 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
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

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();
   }
};

Informações de Versão

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 1.1
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1

Confira Também

MarshalAsAttribute
ComImportAttribute
Namespace System.Runtime.InteropServices

Retornar ao início

Compartilhar via