UnmanagedType Enumeração

Definição

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

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
Herança
UnmanagedType
Atributos

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.

Aplica-se a

Confira também