UnmanagedType Enumeración

Definición

Espacio de nombres:

System.Runtime.InteropServices

Ensamblado:

System.Runtime.dll

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

type UnmanagedType = 

Public Enum UnmanagedType

Herencia

Object

ValueType

Enum

UnmanagedType

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 y 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 Windows Runtime. Este miembro puede usarse en el tipo de datos String. La compatibilidad integrada con WinRT se quitó en .NET 5. Consulte Tipos admitidos previamente integrados para obtener una solución alternativa.
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. La compatibilidad integrada con WinRT se quitó en .NET 5.
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)

Consulte también

• MarshalAsAttribute
• ComImportAttribute