UnmanagedType UnmanagedType UnmanagedType UnmanagedType Enum

Definición

Identifica la forma de calcular las referencias de parámetros o campos en el código no administrado.Identifies how to marshal parameters or fields to unmanaged code.

public enum class UnmanagedType
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum UnmanagedType
type UnmanagedType = 
Public Enum UnmanagedType
Herencia
UnmanagedTypeUnmanagedTypeUnmanagedTypeUnmanagedType
Atributos

Campos

AnsiBStr AnsiBStr AnsiBStr AnsiBStr 35

Cadena de caracteres ANSI que tiene una longitud fija de un solo byte.An ANSI character string that is a length-prefixed single byte. Este miembro puede usarse en el tipo de datos String.You can use this member on the String data type.

AsAny AsAny AsAny 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.A dynamic type that determines the type of an object at run time and marshals the object as that type. Este miembro es válido para los métodos de invocación de plataforma únicamente.This member is valid for platform invoke methods only.

Bool Bool Bool Bool 2

Valor booleano de 4 bytes (true != 0, false = 0).A 4-byte Boolean value (true != 0, false = 0). Se trata del tipo BOOL de Win32.This is the Win32 BOOL type.

BStr BStr BStr BStr 19

Cadena de caracteres Unicode que tiene una longitud fija de doble byte.A Unicode character string that is a length-prefixed double byte. Este miembro, que es la cadena predeterminada en COM, puede utilizarse en el tipo de datos String.You can use this member, which is the default string in COM, on the String data type.

ByValArray ByValArray ByValArray 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.When the Value property is set to ByValArray, the SizeConst field must be set to indicate the number of elements in the array. El campo ArraySubType también puede contener el UnmanagedType de los elementos de la matriz cuando sea necesario diferenciar los tipos de cadenas.The ArraySubType field can optionally contain the UnmanagedType of the array elements when it is necessary to differentiate among string types. UnmanagedType solo puede usarse en una matriz cuyos elementos aparezcan en forma de campos de una estructura.You can use this UnmanagedType only on an array that whose elements appear as fields in a structure.

ByValTStr ByValTStr ByValTStr ByValTStr 23

Se utiliza para matrices en línea de caracteres de longitud fija que aparecen dentro de una estructura.Used for in-line, fixed-length character arrays that appear within a structure. ByValTStr los tipos se comportan como las cadenas de estilo C de tamaño fijo dentro de una estructura (por ejemplo, char s [5]).ByValTStr types behave like C-style, fixed-size strings inside a structure (for example, 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.The character type used with ByValTStr is determined by the CharSet argument of the StructLayoutAttribute attribute applied to the containing structure. Debe utilizarse siempre el campo SizeConst para indicar el tamaño de la matriz.Always use the SizeConst field to indicate the size of the array.

Currency Currency Currency Currency 15

Tipo de divisa.A currency type. Se utiliza en Decimal para calcular las referencias del valor decimal en forma de tipo de divisa COM en lugar de Decimal.Used on a Decimal to marshal the decimal value as a COM currency type instead of as a Decimal.

CustomMarshaler CustomMarshaler CustomMarshaler CustomMarshaler 44

Especifica la clase de contador de referencias personalizado cuando se usa con el campo MarshalType o MarshalTypeRef.Specifies the custom marshaler class when used with the MarshalType or MarshalTypeRef field. El campo MarshalCookie puede utilizarse para pasar información adicional al contador de referencias personalizado.The MarshalCookie field can be used to pass additional information to the custom marshaler. Este miembro puede utilizarse en cualquier tipo de referencia.You can use this member on any reference type. Este miembro es válido solo para parámetros y valores devueltos.This member is valid for parameters and return values only. No se puede usar en campos.It cannot be used on fields.

Error Error Error 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.A native type that is associated with an I4 or an U4 and that causes the parameter to be exported as an HRESULT in the exported type library.

FunctionPtr FunctionPtr FunctionPtr FunctionPtr 38

Entero que puede utilizarse como un puntero de función de estilo C.An integer that can be used as a C-style function pointer. Este miembro puede usarse en un tipo de datos Delegate o en un tipo que se herede de Delegate.You can use this member on a Delegate data type or on a type that inherits from a Delegate.

HString HString HString HString 47

Cadena de Windows en tiempo de ejecuciónWindows Runtime.A Windows en tiempo de ejecuciónWindows Runtime string. Este miembro puede usarse en el tipo de datos String.You can use this member on the String data type.

I1 I1 I1 I1 3

Entero de 1 byte con signo.A 1-byte signed integer. Este miembro puede utilizarse para transformar un valor booleano en un valor bool de estilo C de 1 byte (true = 1, false = 0).You can use this member to transform a Boolean value into a 1-byte, C-style bool (true = 1, false = 0).

I2 I2 I2 I2 5

Entero de 2 bytes con signo.A 2-byte signed integer.

I4 I4 I4 I4 7

Entero de 4 bytes con signo.A 4-byte signed integer.

I8 I8 I8 I8 9

Entero de 8 bytes con signo.An 8-byte signed integer.

IDispatch IDispatch IDispatch IDispatch 26

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

IInspectable IInspectable IInspectable IInspectable 46

Puntero a interfaz Windows en tiempo de ejecuciónWindows Runtime.A Windows en tiempo de ejecuciónWindows Runtime interface pointer. Este miembro puede usarse en el tipo de datos Object.You can use this member on the Object data type.

Interface Interface Interface Interface 28

Puntero a interfaz COM.A COM interface pointer. Guid de la interfaz se obtiene a partir de los metadatos de la clase.The Guid of the interface is obtained from the class metadata. Este miembro se utiliza para especificar el tipo exacto de interfaz o el tipo predeterminado de interfaz si se aplica a una clase.Use this member to specify the exact interface type or the default interface type if you apply it to a class. Este miembro se comporta como IUnknown cuando se aplica al tipo de datos Object.This member produces the same behavior as IUnknown when you apply it to the Object data type.

IUnknown IUnknown IUnknown IUnknown 25

Puntero a IUnknown COM.A COM IUnknown pointer. Este miembro puede usarse en el tipo de datos Object.You can use this member on the Object data type.

LPArray LPArray LPArray LPArray 42

Puntero al primer elemento de una matriz de estilo C.A pointer to the first element of a C-style array. 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.When marshaling from managed to unmanaged code, the length of the array is determined by the length of the managed array. 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.When marshaling from unmanaged to managed code, the length of the array is determined from the SizeConst and SizeParamIndex fields, optionally followed by the unmanaged type of the elements within the array when it is necessary to differentiate among string types.

LPStr LPStr LPStr LPStr 20

Cadena de caracteres ANSI de un solo byte terminada en null.A single byte, null-terminated ANSI character string. Este miembro puede usarse en el tipo de datos String y en el tipo de datos StringBuilder.You can use this member on the String and StringBuilder data types.

LPStruct LPStruct LPStruct LPStruct 43

Puntero a una estructura de estilo C que se utiliza para serializar clases con formato administradas.A pointer to a C-style structure that you use to marshal managed formatted classes. Este miembro es válido para los métodos de invocación de plataforma únicamente.This member is valid for platform invoke methods only.

LPTStr LPTStr LPTStr LPTStr 22

Cadena de caracteres dependientes de la plataforma: ANSI en Windows 98 y Unicode en Windows NT y Windows XP.A platform-dependent character string: ANSI on Windows 98, and Unicode on Windows NT and 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.This value is supported only for platform invoke and not for COM interop, because exporting a string of type LPTStr is not supported.

LPUTF8Str LPUTF8Str LPUTF8Str LPUTF8Str 48

Un puntero a una cadena con codificación UTF-8.A pointer to a UTF-8 encoded string.

LPWStr LPWStr LPWStr LPWStr 21

Cadena de caracteres Unicode de 2 bytes terminada en null.A 2-byte, null-terminated Unicode character string. No puede usar el LPWStr valor con una cadena no administrada a menos que la cadena se creó mediante la no administrada CoTaskMemAlloc función.You cannot use the LPWStr value with an unmanaged string unless the string was created by using the unmanaged CoTaskMemAlloc function.

R4 R4 R4 R4 11

Número de punto flotante de 4 bytes.A 4-byte floating-point number.

R8 R8 R8 R8 12

Número de punto flotante de 8 bytes.An 8-byte floating-point number.

SafeArray SafeArray SafeArray 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.A SafeArray, which is a self-describing array that carries the type, rank, and bounds of the associated array data. Este miembro puede utilizarse con el campo SafeArraySubType para reemplazar el tipo de elemento predeterminado.You can use this member with the SafeArraySubType field to override the default element type.

Struct Struct Struct Struct 27

VARIANT que se utiliza para serializar clases con formato administradas y tipos de valor.A VARIANT, which is used to marshal managed formatted classes and value types.

SysInt SysInt SysInt SysInt 31

Número entero con signo que depende de la plataforma: 4 bytes en Windows de 32 bits, 8 bytes en Windows de 64 bits.A platform-dependent, signed integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

SysUInt SysUInt SysUInt SysUInt 32

Número entero sin signo que depende de la plataforma: 4 bytes en Windows de 32 bits, 8 bytes en Windows de 64 bits.A platform-dependent, unsigned integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

TBStr TBStr TBStr TBStr 36

Cadena char dependiente de la plataforma con longitud fijada previamente: ANSI en Windows 98, Unicode en Windows NT.A length-prefixed, platform-dependent char string: ANSI on Windows 98, Unicode on Windows NT. Este miembro de tipo BSTR se utiliza en raras ocasiones.You rarely use this BSTR-like member.

U1 U1 U1 U1 4

Entero de 1 byte sin signo.A 1-byte unsigned integer.

U2 U2 U2 U2 6

Entero de 2 bytes sin signo.A 2-byte unsigned integer.

U4 U4 U4 U4 8

Entero de 4 bytes sin signo.A 4-byte unsigned integer.

U8 U8 U8 U8 10

Entero de 8 bytes sin signo.An 8-byte unsigned integer.

VariantBool VariantBool VariantBool VariantBool 37

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

VBByRefStr VBByRefStr VBByRefStr 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.A value that enables Visual Basic to change a string in unmanaged code and have the results reflected in managed code. Este valor solo es compatible para la invocación de plataforma.This value is only supported for platform invoke.

Ejemplos

El fragmento de código siguiente muestra cómo declarar, en el código fuente administrado, una interfaz no administrada implementada por un componente COM.The following code fragment demonstrates how to declare, in managed source code, an unmanaged interface implemented by a COM component. El System.Runtime.InteropServices.ComImportAttribute atributo impide que el IMyStorage interfaz desde el que se exportan para su uso por COM.The System.Runtime.InteropServices.ComImportAttribute attribute prevents the IMyStorage interface from being exported back for use by COM. (Los clientes COM deben utilizar el componente COM existente directamente.) En este ejemplo, MarshalAsAttribute especifica varias UnmanagedType miembros, que representan los tipos utilizados por la interfaz de COM original.(COM clients should use the existing COM component directly.) In this example, MarshalAsAttribute specifies several UnmanagedType members, which represent the types used by the original COM interface.

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
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 calculan las referencias de tipos durante la interoperación con código no administrado.Use the UnmanagedType enumeration with the System.Runtime.InteropServices.MarshalAsAttribute attribute to specify how types are marshaled during interoperation with unmanaged code. Esta enumeración se puede usar para calcular las referencias de código con 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.You can use this enumeration to marshal code using simple value types (I1, I2, I4, I8, R4, R8, U2, U4, and U8), unmanaged types that are unavailable in the .NET Framework, and various miscellaneous types.

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

Se aplica a

Consulte también: