UnmanagedType Enumeración

Definición

Identifica la forma de calcular las referencias de parámetros o campos en el código no administrado.

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
Herencia
UnmanagedType
Atributos

Campos

AnsiBStr 35

Cadena de caracteres ANSI que tiene una longitud fija de un solo byte. Este miembro puede usarse en el tipo de datos String.

AsAny 40

Tipo dinámico que determina el tipo de un objeto en tiempo de ejecución y calcula las referencias del objeto como de dicho tipo. Este miembro es válido para los métodos de invocación de plataforma únicamente.

Bool 2

Valor booleano de 4 bytes (true != 0, false = 0). Se trata del tipo BOOL de Win32.

BStr 19

Cadena de caracteres Unicode que tiene una longitud fija de doble byte. Este miembro, que es la cadena predeterminada en COM, puede utilizarse en el tipo de datos String.

ByValArray 30

Cuando la propiedad Value se establece en ByValArray, el campo SizeConst debe establecerse de modo que indique el número de elementos de la matriz. El campo ArraySubType también puede contener el UnmanagedType de los elementos de la matriz cuando sea necesario diferenciar los tipos de cadenas. UnmanagedType solo puede usarse en una matriz cuyos elementos aparezcan en forma de campos de una estructura.

ByValTStr 23

Se utiliza para matrices en línea de caracteres de longitud fija que aparecen dentro de una estructura. ByValTStr los tipos se comportan como cadenas de tamaño fijo, de estilo C dentro de una estructura (por ejemplo, char s[5]). El tipo de caracteres usado con ByValTStr viene determinado por el argumento CharSet del atributo StructLayoutAttribute que se aplica a la estructura contenedora. Debe utilizarse siempre el campo SizeConst para indicar el tamaño de la matriz.

Currency 15

Tipo de divisa. Se utiliza en Decimal para calcular las referencias del valor decimal en forma de tipo de divisa COM en lugar de Decimal.

CustomMarshaler 44

Especifica la clase de contador de referencias personalizado cuando se usa con el campo MarshalType o MarshalTypeRef. El campo MarshalCookie puede utilizarse para pasar información adicional al contador de referencias personalizado. Este miembro puede utilizarse en cualquier tipo de referencia. Este miembro es válido solo para parámetros y valores devueltos. No se puede usar en campos.

Error 45

Tipo nativo asociado a I4 o a U4 y que hace que el parámetro se exporte como un valor HRESULT a la biblioteca de tipos exportada.

FunctionPtr 38

Entero que puede utilizarse como un puntero de función de estilo C. Este miembro puede usarse en un tipo de datos Delegate o en un tipo que se herede de Delegate.

HString 47

Cadena de Windows Runtime. Este miembro puede usarse en el tipo de datos String.

I1 3

Entero de 1 byte con signo. Este miembro puede utilizarse para transformar un valor booleano en un valor bool de estilo C de 1 byte (true = 1, false = 0).

I2 5

Entero de 2 bytes con signo.

I4 7

Entero de 4 bytes con signo.

I8 9

Entero de 8 bytes con signo.

IDispatch 26

Puntero de interfaz IDispatch COM (Object en Microsoft Visual Basic 6.0).

IInspectable 46

Puntero de interfaz Windows Runtime. Este miembro puede usarse en el tipo de datos Object.

Interface 28

Puntero a interfaz COM. Guid de la interfaz se obtiene a partir de los metadatos de la clase. Este miembro se utiliza para especificar el tipo exacto de interfaz o el tipo predeterminado de interfaz si se aplica a una clase. Este miembro se comporta como IUnknown cuando se aplica al tipo de datos Object.

IUnknown 25

Puntero a IUnknown COM. Este miembro puede usarse en el tipo de datos Object.

LPArray 42

Puntero al primer elemento de una matriz de estilo C. Cuando se calculan las referencias de código administrado a no administrado, la longitud de la matriz viene determinada por la longitud de la matriz administrada. Cuando se calculan las referencias de código no administrado a código administrado, la longitud de la matriz se determina a partir de los campos SizeConst y SizeParamIndex seguidos, de forma opcional, del tipo no administrado de los elementos de la matriz cuando es necesario distinguir los tipos de cadena.

LPStr 20

Cadena de caracteres ANSI de un solo byte terminada en null. Este miembro puede usarse en el tipo de datos String y en el tipo de datos StringBuilder.

LPStruct 43

Puntero a una estructura de estilo C que se utiliza para serializar clases con formato administradas. Este miembro es válido para los métodos de invocación de plataforma únicamente.

LPTStr 22

Cadena de caracteres Unicode. Este valor solo se admite para llamadas a la plataforma y no para la interoperabilidad COM, porque no se admite la exportación de una cadena de tipo LPTStr.

LPUTF8Str 48

Un puntero a una cadena con codificación UTF-8.

LPWStr 21

Cadena de caracteres Unicode de 2 bytes terminada en null. No se puede usar el valor LPWStr con una cadena no administrada a menos que la cadena se haya creado mediante la función CoTaskMemAlloc no administrada.

R4 11

Número de punto flotante de 4 bytes.

R8 12

Número de punto flotante de 8 bytes.

SafeArray 29

Matriz SafeArray que se describe a sí misma y que contiene el tipo, rango y límites de los datos de la matriz asociada. Este miembro puede utilizarse con el campo SafeArraySubType para reemplazar el tipo de elemento predeterminado.

Struct 27

VARIANT que se utiliza para serializar clases con formato administradas y tipos de valor.

SysInt 31

Entero con signo que depende de una plataforma: 4 bytes en Windows de 32 bits, 8 bytes en Windows de 64 bits.

SysUInt 32

Entero sin signo que depende de una plataforma: 4 bytes en Windows de 32 bits, 8 bytes en Windows de 64 bits.

TBStr 36

Cadena Unicode char con prefijo de longitud. Este miembro de tipo BSTR se utiliza en raras ocasiones.

U1 4

Entero de 1 byte sin signo.

U2 6

Entero de 2 bytes sin signo.

U4 8

Entero de 4 bytes sin signo.

U8 10

Entero de 8 bytes sin signo.

VariantBool 37

Tipo VARIANT_BOOL de 2 bytes definido por OLE (true = -1, false = 0).

VBByRefStr 34

Un valor que permite a Visual Basic cambiar una cadena del código no administrado y reflejar los resultados en código administrado. Este valor solo es compatible para la invocación de plataforma.

Ejemplos

En el fragmento de código siguiente se muestra cómo declarar, en código fuente administrado, una interfaz no administrada implementada por un componente COM. El System.Runtime.InteropServices.ComImportAttribute atributo impide que la IMyStorage interfaz se exporte de nuevo para su uso por COM. (Los clientes COM deben usar directamente el componente COM existente). En este ejemplo, MarshalAsAttribute especifica varios UnmanagedType miembros, que representan los tipos usados por la interfaz 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

Comentarios

Use la UnmanagedType enumeración con el System.Runtime.InteropServices.MarshalAsAttribute atributo para especificar cómo se serializarán los tipos durante la interoperación con código no administrado. Puede usar esta enumeración para serializar código mediante tipos de valor simples (I1, I2, I4, I8, R4, R8, U2, U4 y U8), tipos no administrados que no están disponibles en .NET Framework y varios tipos varios.

Para más información, consulte Interoperating with Unmanaged Code (Interoperar con código no administrado)

Se aplica a

Consulte también