UnmanagedType UnmanagedType UnmanagedType UnmanagedType Enum

Definizione

Identifica come eseguire il marshalling di parametri o campi nel codice gestito.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
Ereditarietà
UnmanagedTypeUnmanagedTypeUnmanagedTypeUnmanagedType
Attributi

Campi

AnsiBStr AnsiBStr AnsiBStr AnsiBStr 35

Stringa di caratteri ANSI costituita da un singolo byte con prefisso di lunghezza.An ANSI character string that is a length-prefixed single byte. È possibile usare questo membro nel tipo di dati String.You can use this member on the String data type.

AsAny AsAny AsAny AsAny 40

Tipo dinamico che determina il tipo di un oggetto in fase di esecuzione ed effettua il marshalling dell'oggetto come quel tipo.A dynamic type that determines the type of an object at run time and marshals the object as that type. Questo membro è valido solo per metodi di platform invoke.This member is valid for platform invoke methods only.

Bool Bool Bool Bool 2

Valore booleano a 4 byte (true != 0, false = 0).A 4-byte Boolean value (true != 0, false = 0). Si tratta del tipo BOOL Win32.This is the Win32 BOOL type.

BStr BStr BStr BStr 19

Stringa di caratteri Unicode costituita da un byte doppio con prefisso di lunghezza.A Unicode character string that is a length-prefixed double byte. È possibile usare questo membro, ovvero la stringa predefinita in COM, nel tipo di dati String.You can use this member, which is the default string in COM, on the String data type.

ByValArray ByValArray ByValArray ByValArray 30

Quando la proprietà Value è impostata su ByValArray, il campo SizeConst deve essere impostato per indicare il numero di elementi nella matrice.When the Value property is set to ByValArray, the SizeConst field must be set to indicate the number of elements in the array. Il campo ArraySubType può contenere facoltativamente l'oggetto UnmanagedType degli elementi della matrice quando è necessario distinguere tra più tipi di stringa.The ArraySubType field can optionally contain the UnmanagedType of the array elements when it is necessary to differentiate among string types. È possibile usare solo questo oggetto UnmanagedType in una matrice i cui elementi vengono visualizzati come campi in una struttura.You can use this UnmanagedType only on an array that whose elements appear as fields in a structure.

ByValTStr ByValTStr ByValTStr ByValTStr 23

Usato per matrici di caratteri di lunghezza fissa inline visualizzate all'interno di una struttura.Used for in-line, fixed-length character arrays that appear within a structure. ByValTStr i tipi si comportano come le stringhe di tipo C, a dimensione fissa all'interno di una struttura (ad esempio, s char [5]).ByValTStr types behave like C-style, fixed-size strings inside a structure (for example, char s[5]). Il tipo di carattere usato con ByValTStr è determinato dall'argomento CharSet dell'attributo StructLayoutAttribute applicato alla struttura che lo contiene.The character type used with ByValTStr is determined by the CharSet argument of the StructLayoutAttribute attribute applied to the containing structure. Usare sempre il campo SizeConst per indicare le dimensioni della matrice.Always use the SizeConst field to indicate the size of the array.

Currency Currency Currency Currency 15

Tipo di valuta.A currency type. Usato su un oggetto Decimal per effettuare il marshalling del valore decimale come tipo di valuta COM anziché come 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

Specifica la classe del gestore di marshalling personalizzato quando è usato con il campo MarshalType o MarshalTypeRef.Specifies the custom marshaler class when used with the MarshalType or MarshalTypeRef field. È possibile usare il campo MarshalCookie per passare informazioni aggiuntive al gestore di marshalling personalizzato.The MarshalCookie field can be used to pass additional information to the custom marshaler. È possibile usare questo membro su qualsiasi tipo di riferimento.You can use this member on any reference type. Questo membro è valido solo per i parametri e i valori restituiti.This member is valid for parameters and return values only. Non può essere usato nei campi.It cannot be used on fields.

Error Error Error Error 45

Tipo nativo associato a I4 o a U4 e che determina l'esportazione del parametro come HRESULT nella libreria dei tipi esportata.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

Intero che può essere usato come puntatore a funzione di tipo C.An integer that can be used as a C-style function pointer. È possibile usare questo membro in un tipo di dati Delegate o in un tipo che eredita da 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

Stringa Windows RuntimeWindows Runtime.A Windows RuntimeWindows Runtime string. È possibile usare questo membro nel tipo di dati String.You can use this member on the String data type.

I1 I1 I1 I1 3

Intero con segno a 1 byte.A 1-byte signed integer. È possibile usare questo membro per trasformare un valore booleano in un valore bool a 1 byte di tipo C (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

Intero con segno a 2 byte.A 2-byte signed integer.

I4 I4 I4 I4 7

Intero con segno a 4 byte.A 4-byte signed integer.

I8 I8 I8 I8 9

Intero con segno a 8 byte.An 8-byte signed integer.

IDispatch IDispatch IDispatch IDispatch 26

Puntatore a IDispatch COM (Object in Microsoft Visual Basic 6.0).A COM IDispatch pointer (Object in Microsoft Visual Basic 6.0).

IInspectable IInspectable IInspectable IInspectable 46

Puntatore a interfaccia Windows RuntimeWindows Runtime.A Windows RuntimeWindows Runtime interface pointer. È possibile usare questo membro nel tipo di dati Object.You can use this member on the Object data type.

Interface Interface Interface Interface 28

Puntatore a interfaccia COM.A COM interface pointer. L'oggetto Guid dell'interfaccia è ottenuto dai metadati della classe.The Guid of the interface is obtained from the class metadata. Usare questo membro per specificare il tipo di interfaccia esatto o il tipo di interfaccia predefinito se lo si applica a una classe.Use this member to specify the exact interface type or the default interface type if you apply it to a class. Questo membro produce lo stesso comportamento di IUnknown quando lo si applica al tipo di dati Object.This member produces the same behavior as IUnknown when you apply it to the Object data type.

IUnknown IUnknown IUnknown IUnknown 25

Puntatore a IUnknown COM.A COM IUnknown pointer. È possibile usare questo membro nel tipo di dati Object.You can use this member on the Object data type.

LPArray LPArray LPArray LPArray 42

Puntatore al primo elemento di una matrice di tipo C.A pointer to the first element of a C-style array. Quando si effettua il marshalling da codice gestito a non gestito, la lunghezza della matrice dipende dalla lunghezza della matrice gestita.When marshaling from managed to unmanaged code, the length of the array is determined by the length of the managed array. Quando si effettua il marshalling da codice non gestito a gestito, la lunghezza della matrice dipende dai campi SizeConst e SizeParamIndex, facoltativamente seguiti dal tipo non gestito degli elementi all'interno della matrice quando è necessario distinguere tra più tipi di stringa.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

Stringa di caratteri ANSI a un byte a terminazione Null.A single byte, null-terminated ANSI character string. È possibile usare questo membro nei tipi di dati String e StringBuilder.You can use this member on the String and StringBuilder data types.

LPStruct LPStruct LPStruct LPStruct 43

Puntatore a una struttura di tipo C usata per effettuare il marshalling di classi formattate gestite.A pointer to a C-style structure that you use to marshal managed formatted classes. Questo membro è valido solo per metodi di platform invoke.This member is valid for platform invoke methods only.

LPTStr LPTStr LPTStr LPTStr 22

Stringa di caratteri dipendente dalla piattaforma: ANSI in Windows 98 e Unicode in Windows NT e Windows XP.A platform-dependent character string: ANSI on Windows 98, and Unicode on Windows NT and Windows XP. Questo valore è supportato solo per platform invoke, non per l'interoperabilità COM, perché l'esportazione di una stringa di tipo LPTStr non è supportata.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

Puntatore a una stringa con codifica UTF-8.A pointer to a UTF-8 encoded string.

LPWStr LPWStr LPWStr LPWStr 21

Stringa di caratteri Unicode a 2 byte a terminazione Null.A 2-byte, null-terminated Unicode character string. Non è possibile usare la LPWStr valore con una stringa non gestita, a meno che la stringa è stata creata utilizzando non gestito CoTaskMemAlloc (funzione).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

Numero a virgola mobile a 4 byte.A 4-byte floating-point number.

R8 R8 R8 R8 12

Numero a virgola mobile a 8 byte.An 8-byte floating-point number.

SafeArray SafeArray SafeArray SafeArray 29

SafeArray è una matrice autodescrittiva che contiene il tipo, la dimensione e i limiti dei dati della matrice associati.A SafeArray, which is a self-describing array that carries the type, rank, and bounds of the associated array data. È possibile usare questo membro con il campo SafeArraySubType per eseguire l'override del tipo di elemento predefinito.You can use this member with the SafeArraySubType field to override the default element type.

Struct Struct Struct Struct 27

VARIANT usato per effettuare il marshalling di tipi valore e classi formattate gestite.A VARIANT, which is used to marshal managed formatted classes and value types.

SysInt SysInt SysInt SysInt 31

Intero con segno dipendente dalla piattaforma: 4 byte in Windows a 32 bit, 8 byte in Windows a 64 bit.A platform-dependent, signed integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

SysUInt SysUInt SysUInt SysUInt 32

Intero senza segno dipendente dalla piattaforma: 4 byte in Windows a 32 bit, 8 byte in Windows a 64 bit.A platform-dependent, unsigned integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

TBStr TBStr TBStr TBStr 36

Stringa char dipendente dalla piattaforma con prefisso della lunghezza: ANSI in Windows 98, Unicode in Windows NT.A length-prefixed, platform-dependent char string: ANSI on Windows 98, Unicode on Windows NT. Questo membro simile a BSTR viene usato raramente.You rarely use this BSTR-like member.

U1 U1 U1 U1 4

Intero senza segno a 1 byte.A 1-byte unsigned integer.

U2 U2 U2 U2 6

Intero senza segno a 2 byte.A 2-byte unsigned integer.

U4 U4 U4 U4 8

Intero senza segno a 4 byte.A 4-byte unsigned integer.

U8 U8 U8 U8 10

Intero senza segno a 8 byte.An 8-byte unsigned integer.

VariantBool VariantBool VariantBool VariantBool 37

Tipo VARIANT_BOOL definito da OLE a 2 byte (true = -1, false = 0).A 2-byte, OLE-defined VARIANT_BOOL type (true = -1, false = 0).

VBByRefStr VBByRefStr VBByRefStr VBByRefStr 34

Valore che consente a Visual Basic di modificare una stringa in codice non gestito e riflettere i risultati in codice gestito.A value that enables Visual Basic to change a string in unmanaged code and have the results reflected in managed code. Questo valore è supportato solo per platform invoke.This value is only supported for platform invoke.

Esempi

Il frammento di codice seguente viene illustrato come dichiarare, nel codice sorgente gestito, un'interfaccia non gestita implementata da un componente COM.The following code fragment demonstrates how to declare, in managed source code, an unmanaged interface implemented by a COM component. Il System.Runtime.InteropServices.ComImportAttribute attributo impedisce la IMyStorage interfaccia dall'esportazione nuovamente per l'utilizzo da COM.The System.Runtime.InteropServices.ComImportAttribute attribute prevents the IMyStorage interface from being exported back for use by COM. (I client COM devono usare il componente COM esistente direttamente.) In questo esempio MarshalAsAttribute specifica diverse UnmanagedType membri che rappresentano i tipi usati dall'interfaccia COM originale.(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

Commenti

Usare la UnmanagedType enumerazione con i System.Runtime.InteropServices.MarshalAsAttribute attributo per specificare la modalità di marshalling di tipi durante l'interoperabilità con codice non gestito.Use the UnmanagedType enumeration with the System.Runtime.InteropServices.MarshalAsAttribute attribute to specify how types are marshaled during interoperation with unmanaged code. Effettuare il marshalling di codice che Usa valori semplici tipi (I1, I2, I4, I8, R4, R8, U2, U4 e U8), tipi non gestiti che non sono disponibili in .NET Framework e altri tipi diversi, è possibile utilizzare questa enumerazione.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.

Per altre informazioni, vedere Interoperabilità con codice non gestito.For more information, see Interoperating with Unmanaged Code.

Si applica a

Vedi anche