Enumeración UnmanagedType

Artículo
04/18/2017

Publicado: octubre de 2016

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

Espacio de nombres: System.Runtime.InteropServices
Ensamblado: mscorlib (en mscorlib.dll)

Sintaxis

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

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

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

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

Miembros

	Nombre de miembro	Descripción
	AnsiBStr	Cadena de caracteres ANSI que tiene una longitud fija de un solo byte. Este miembro puede usarse en el tipo de datos String.
	AsAny	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	Valor booleano de 4 bytes (true != 0, false = 0). Se trata del tipo BOOL de Win32.
	BStr	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	Cuando la propiedad MarshalAsAttribute.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	Se utiliza para matrices en línea de caracteres de longitud fija que aparecen dentro de una estructura. El tipo de caracteres usado con ByValTStr viene determinado por el argumento System.Runtime.InteropServices.CharSet del atributo System.Runtime.InteropServices.StructLayoutAttribute que se aplica a la estructura contenedora. Debe utilizarse siempre el campo MarshalAsAttribute.SizeConst para indicar el tamaño de la matriz.
	Currency	Tipo de divisa. Se utiliza en System.Decimal para calcular las referencias del valor decimal en forma de tipo de divisa COM en lugar de Decimal.
	CustomMarshaler	Especifica la clase de contador de referencias personalizado cuando se usa con el campo MarshalAsAttribute.MarshalType o MarshalAsAttribute.MarshalTypeRef. El campo MarshalAsAttribute.MarshalCookie puede utilizarse para pasar información adicional al contador de referencias personalizado. Este miembro puede utilizarse en cualquier tipo de referencia.
	Error	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	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	Cadena de Windows en tiempo de ejecución. Este miembro puede usarse en el tipo de datos System.String.
	I1	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	Entero de 2 bytes con signo.
	I4	Entero de 4 bytes con signo.
	I8	Entero de 8 bytes con signo.
	IDispatch	Puntero de interfaz IDispatch COM (Object en Microsoft Visual Basic 6.0).
	IInspectable	Puntero a interfaz Windows en tiempo de ejecución. Este miembro puede usarse en el tipo de datos Object.
	Interface	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 UnmanagedType.IUnknown cuando se aplica al tipo de datos Object.
	IUnknown	Puntero a IUnknown COM. Este miembro puede usarse en el tipo de datos Object.
	LPArray	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 MarshalAsAttribute.SizeConst y MarshalAsAttribute.SizeParamIndex seguidos, de forma opcional, del tipo no administrado de los elementos de la matriz cuando es necesario distinguir los tipos de cadena.
	LPStr	Cadena de caracteres ANSI de un solo byte terminada en null. Este miembro puede usarse en el tipo de datos System.String y en el tipo de datos System.Text.StringBuilder.
	LPStruct	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	Cadena de caracteres que depende de la plataforma: ANSI en Windows 98 y Unicode en Windows NT y Windows XP. 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	Un puntero a una cadena con codificación UTF-8.
	LPWStr	Cadena de caracteres Unicode de 2 bytes terminada en null.
	R4	Número de punto flotante de 4 bytes.
	R8	Número de punto flotante de 8 bytes.
	SafeArray	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 MarshalAsAttribute.SafeArraySubType para reemplazar el tipo de elemento predeterminado.
	Struct	VARIANT que se utiliza para serializar clases con formato administradas y tipos de valor.
	SysInt	Entero con signo que depende de una plataforma: 4 bytes en Windows de 32 bits, 8 bytes en Windows de 64 bits.
	SysUInt	Entero sin signo que depende de una plataforma: 4 bytes en Windows de 32 bits, 8 bytes en Windows de 64 bits.
	TBStr	Cadena de char de longitud fija que depende de la plataforma: ANSI en Windows 98, Unicode en Windows NT. Este miembro de tipo BSTR se utiliza en raras ocasiones.
	U1	Entero de 1 byte sin signo.
	U2	Entero de 2 bytes sin signo.
	U4	Entero de 4 bytes sin signo.
	U8	Entero de 8 bytes sin signo.
	VariantBool	Tipo VARIANT_BOOL de 2 bytes definido por OLE (true = -1, false = 0).
	VBByRefStr	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.

Comentarios

Utilice la UnmanagedType enumeración con el System.Runtime.InteropServices.MarshalAsAttribute atributo para especificar cómo se calculan las referencias de tipos durante la interoperación con código no administrado. Puede usar esta enumeración para calcular las referencias de código mediante un valor simple tipos (I1, I2, I4, I8, R4, R8, U2, U4 y U8), tipos no administrados que no están disponibles en .NET Framework y otros tipos diversos.

Para obtener más información, consulta Interoperating with Unmanaged Code.

Ejemplos

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

Información de versión

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Ver también

MarshalAsAttribute
ComImportAttribute
Espacio de nombres System.Runtime.InteropServices

Volver al principio

Compartir a través de