UnmanagedType UnmanagedType UnmanagedType UnmanagedType Enum

Definition

Gibt an, wie Parameter oder Felder in nicht verwaltetem Code gemarshallt werden.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
Vererbung
UnmanagedTypeUnmanagedTypeUnmanagedTypeUnmanagedType
Attribute

Felder

AnsiBStr AnsiBStr AnsiBStr AnsiBStr 35

Eine Zeichenfolge aus ANSI-Zeichen, die ein Einzelbyte mit Längenpräfix ist.An ANSI character string that is a length-prefixed single byte. Sie können diesen Member für den String-Datentyp verwenden.You can use this member on the String data type.

AsAny AsAny AsAny AsAny 40

Ein dynamischer Typ, der zur Laufzeit den Typ eines Objekts bestimmt und das Objekt als diesen Typ marshallt.A dynamic type that determines the type of an object at run time and marshals the object as that type. Dieser Member ist nur für Plattformaufrufmethoden gültig.This member is valid for platform invoke methods only.

Bool Bool Bool Bool 2

Ein boolescher Wert mit 4 Bytes (true != 0, false = 0).A 4-byte Boolean value (true != 0, false = 0). Dies ist der Win32-BOOL-Typ.This is the Win32 BOOL type.

BStr BStr BStr BStr 19

Eine Zeichenfolge aus Unicode-Zeichen, die ein Doppelbyte mit Längenpräfix ist.A Unicode character string that is a length-prefixed double byte. Sie können diesen Member, der die Standardzeichenfolge in COM darstellt, für den String-Datentyp verwenden.You can use this member, which is the default string in COM, on the String data type.

ByValArray ByValArray ByValArray ByValArray 30

Wenn die Value-Eigenschaft auf ByValArray festgelegt wird, muss das SizeConst-Feld so festgelegt werden, dass die Anzahl der Elemente im Array angegeben wird.When the Value property is set to ByValArray, the SizeConst field must be set to indicate the number of elements in the array. Das Feld ArraySubType kann optional den UnmanagedType der Arrayelemente enthalten, wenn zwischen verschiedenen Zeichenfolgetypen unterschieden werden muss.The ArraySubType field can optionally contain the UnmanagedType of the array elements when it is necessary to differentiate among string types. Sie können diesen UnmanagedType nur für ein Array verwenden, dessen Elemente in einer Struktur in Form von Feldern angezeigt werden.You can use this UnmanagedType only on an array that whose elements appear as fields in a structure.

ByValTStr ByValTStr ByValTStr ByValTStr 23

Wird für Inlinearrays mit Zeichen fester Länge verwendet, die in einer Struktur dargestellt werden.Used for in-line, fixed-length character arrays that appear within a structure. ByValTStr-Typen verhalten sich wie Zeichenfolgen im C-Stil mit fester Größe innerhalb einer Struktur (beispielsweise char s[5]).ByValTStr types behave like C-style, fixed-size strings inside a structure (for example, char s[5]). Der in ByValTStr verwendete Zeichentyp wird durch das CharSet-Argument des StructLayoutAttribute-Attributs bestimmt, das auf die enthaltende Struktur angewendet wird.The character type used with ByValTStr is determined by the CharSet argument of the StructLayoutAttribute attribute applied to the containing structure. Verwenden Sie immer das SizeConst-Feld, um die Größe des Arrays anzugeben.Always use the SizeConst field to indicate the size of the array.

Currency Currency Currency Currency 15

Ein Währungstyp.A currency type. Wird für Decimal verwendet, um den Dezimalwert als COM-Währungstyp und nicht alsDecimal zu marshallen.Used on a Decimal to marshal the decimal value as a COM currency type instead of as a Decimal.

CustomMarshaler CustomMarshaler CustomMarshaler CustomMarshaler 44

Gibt bei Verwendung mit MarshalType oder MarshalTypeRef-Feld die benutzerdefinierte Marshaller-Klasse an.Specifies the custom marshaler class when used with the MarshalType or MarshalTypeRef field. Das Feld MarshalCookie kann zum Übergeben zusätzlicher Informationen an den benutzerdefinierten Marshaller verwendet werden.The MarshalCookie field can be used to pass additional information to the custom marshaler. Sie können diesen Member für beliebige Verweistypen verwenden.You can use this member on any reference type. Dieser Member ist nur für Parameter und Rückgabewerte gültig.This member is valid for parameters and return values only. Er kann nicht für Felder verwendet werden.It cannot be used on fields.

Error Error Error Error 45

Ein systemeigener Typ, der mit einem I4 oder einem U4 verknüpfte ist und bewirkt, dass der Parameter als ein HRESULT in die Bibliothek mit den Exporttypen exportiert wird.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

Eine Ganzzahl, die als C-Funktionszeiger verwendet werden kann.An integer that can be used as a C-style function pointer. Sie können diesen Member für einen Delegate-Datentyp oder einen Typ verwenden, der von einem Delegate erbt.You can use this member on a Delegate data type or on a type that inherits from a Delegate.

HString HString HString HString 47

Eine Windows-RuntimeWindows Runtime-Zeichenfolge.A Windows-RuntimeWindows Runtime string. Sie können diesen Member für den Datentyp String verwenden.You can use this member on the String data type.

I1 I1 I1 I1 3

Eine 1-Byte-Ganzzahl mit Vorzeichen.A 1-byte signed integer. Sie können mit diesem Member einen booleschen Wert in einen 1-Byte-bool im C-Format (true = 1, false = 0) transformieren.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

Eine 2-Byte-Ganzzahl mit Vorzeichen.A 2-byte signed integer.

I4 I4 I4 I4 7

Eine 4-Byte-Ganzzahl mit Vorzeichen.A 4-byte signed integer.

I8 I8 I8 I8 9

Eine 8-Byte-Ganzzahl mit Vorzeichen.An 8-byte signed integer.

IDispatch IDispatch IDispatch IDispatch 26

Ein IDispatch-Zeiger in COM (Object in Microsoft Visual Basic 6.0).A COM IDispatch pointer (Object in Microsoft Visual Basic 6.0).

IInspectable IInspectable IInspectable IInspectable 46

Ein Windows-RuntimeWindows Runtime-Schnittstellenzeiger.A Windows-RuntimeWindows Runtime interface pointer. Sie können diesen Member für den Datentyp Object verwenden.You can use this member on the Object data type.

Interface Interface Interface Interface 28

Ein COM-Schnittstellenzeiger.A COM interface pointer. Die Guid der Schnittstelle wird aus den Metadaten der Klasse ermittelt.The Guid of the interface is obtained from the class metadata. Mit diesem Member geben Sie den genauen Schnittstellentyp oder den Standardschnittstellentyp an, wenn Sie ihn auf eine Klasse anwenden.Use this member to specify the exact interface type or the default interface type if you apply it to a class. Dieser Member bewirkt das gleiche Verhalten wie IUnknown, wenn sie ihn auf den Object-Datentyp anwenden.This member produces the same behavior as IUnknown when you apply it to the Object data type.

IUnknown IUnknown IUnknown IUnknown 25

Ein COM-IUnknown-Zeiger.A COM IUnknown pointer. Sie können diesen Member für den Datentyp Object verwenden.You can use this member on the Object data type.

LPArray LPArray LPArray LPArray 42

Ein Zeiger auf das erste Element eines C-Arrays.A pointer to the first element of a C-style array. Beim Marshallen von verwaltetem zu nicht verwalteten Code wird die Länge des Arrays anhand der Länge des verwalteten Arrays bestimmt.When marshaling from managed to unmanaged code, the length of the array is determined by the length of the managed array. Beim Marshallen von nicht verwaltetem in verwalteten Code wird die Länge des Arrays vom SizeConst-Feld und vom SizeParamIndex-Feld bestimmt, auf die optional der nicht verwaltete Typ der Elemente im Array folgt, wenn eine Unterscheidung zwischen Zeichenfolgentypen erforderlich ist.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

Eine aus ANSI-Zeichen bestehende, mit NULL beendete Einzelbyte-Zeichenfolge.A single byte, null-terminated ANSI character string. Sie können diesen Member für den String-Datentyp und den StringBuilder-Datentyp verwenden.You can use this member on the String and StringBuilder data types.

LPStruct LPStruct LPStruct LPStruct 43

Ein Zeiger auf eine C-Struktur, mit dem verwaltete formatierte Klassen gemarshallt werden.A pointer to a C-style structure that you use to marshal managed formatted classes. Dieser Member ist nur für Plattformaufrufmethoden gültig.This member is valid for platform invoke methods only.

LPTStr LPTStr LPTStr LPTStr 22

Eine plattformabhängige Zeichenfolge: ANSI unter Windows 98 und Unicode unter Windows NT und Windows XP.A platform-dependent character string: ANSI on Windows 98, and Unicode on Windows NT and Windows XP. Dieser Wert wird nur für Plattformaufrufe und nicht für COM-Interop unterstützt, da das Exportieren einer Zeichenfolge vom Typ LPTStr nicht unterstützt wird.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

Ein Zeiger auf eine UTF-8-Zeichenfolge.A pointer to a UTF-8 encoded string.

LPWStr LPWStr LPWStr LPWStr 21

Eine aus Unicode-Zeichen bestehende, mit NULL beendete 2-Byte-Zeichenfolge.A 2-byte, null-terminated Unicode character string. Der Wert LPWStr kann nicht mit einer nicht verwalteten Zeichenfolge verwendet werden, es sei denn, die Zeichenfolge wurde mit der nicht verwalteten CoTaskMemAlloc-Funktion erstellt.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

Eine 4-Byte-Gleitkommazahl.A 4-byte floating-point number.

R8 R8 R8 R8 12

Eine 8-Byte-Gleitkommazahl.An 8-byte floating-point number.

SafeArray SafeArray SafeArray SafeArray 29

Ein SafeArray ist ein selbstbeschreibendes Array mit dem Typ, dem Rang und den Grenzen der verknüpften Arraydaten.A SafeArray, which is a self-describing array that carries the type, rank, and bounds of the associated array data. Sie können diesen Member mit dem SafeArraySubType-Feld verwenden, um den Standardelementtyp zu überschreiben.You can use this member with the SafeArraySubType field to override the default element type.

Struct Struct Struct Struct 27

Ein VARIANT zum Marshallen verwalteter formatierter Klassen und Werttypen.A VARIANT, which is used to marshal managed formatted classes and value types.

SysInt SysInt SysInt SysInt 31

Eine plattformabhängige Ganzzahl mit Vorzeichen: 4 Byte für 32-Bit-Windows, 8 Bytes für 64-Bit-Windows.A platform-dependent, signed integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

SysUInt SysUInt SysUInt SysUInt 32

Eine plattformabhängige Ganzzahl ohne Vorzeichen: 4 Byte für 32-Bit-Windows, 8 Bytes für 64-Bit-Windows.A platform-dependent, unsigned integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

TBStr TBStr TBStr TBStr 36

Eine plattformabhängige char-Zeichenfolge mit Längenpräfix: ANSI unter Windows 98, Unicode unter Windows NT.A length-prefixed, platform-dependent char string: ANSI on Windows 98, Unicode on Windows NT. Dieser BSTR-ähnliche Member wird nur selten verwendet.You rarely use this BSTR-like member.

U1 U1 U1 U1 4

Eine 1-Byte-Ganzzahl ohne Vorzeichen.A 1-byte unsigned integer.

U2 U2 U2 U2 6

Eine 2-Byte-Ganzzahl ohne Vorzeichen.A 2-byte unsigned integer.

U4 U4 U4 U4 8

Eine 4-Byte-Ganzzahl ohne Vorzeichen.A 4-byte unsigned integer.

U8 U8 U8 U8 10

Eine 8-Byte-Ganzzahl ohne Vorzeichen.An 8-byte unsigned integer.

VariantBool VariantBool VariantBool VariantBool 37

Ein durch OLE definierter VARIANT_BOOL-Typ mit 2 Bytes (true = -1, false = 0).A 2-byte, OLE-defined VARIANT_BOOL type (true = -1, false = 0).

VBByRefStr VBByRefStr VBByRefStr VBByRefStr 34

Ein Wert, der es Visual Basic ermöglicht, eine Zeichenfolge in nicht verwaltetem Code zu ändern und die Ergebnisse in verwaltetem Code wiederzugeben.A value that enables Visual Basic to change a string in unmanaged code and have the results reflected in managed code. Dieser Wert wird nur für Plattformaufrufe unterstützt.This value is only supported for platform invoke.

Beispiele

Im folgenden Code Fragment wird veranschaulicht, wie eine nicht verwaltete Schnittstelle, die von einer COM-Komponente implementiert wird, in verwaltetem Quellcode deklariert wird.The following code fragment demonstrates how to declare, in managed source code, an unmanaged interface implemented by a COM component. Das System.Runtime.InteropServices.ComImportAttribute -Attribut verhindert IMyStorage , dass die-Schnittstelle zur Verwendung durch com zurück exportiert wird.The System.Runtime.InteropServices.ComImportAttribute attribute prevents the IMyStorage interface from being exported back for use by COM. (Com-Clients sollten die vorhandene COM-Komponente direkt verwenden.) In diesem Beispiel MarshalAsAttribute gibt mehrere UnmanagedType Member an, die die von der ursprünglichen COM-Schnittstelle verwendeten Typen darstellen.(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

Hinweise

Verwenden Sie UnmanagedType die-Enumeration System.Runtime.InteropServices.MarshalAsAttribute mit dem-Attribut, um anzugeben, wie Typen während der Interoperation mit nicht verwaltetem Code gemarshallt werden.Use the UnmanagedType enumeration with the System.Runtime.InteropServices.MarshalAsAttribute attribute to specify how types are marshaled during interoperation with unmanaged code. Sie können diese Enumeration verwenden, um Code mithilfe einfacher Werttypen (I1, I2, I4, I8, R4, R8, U2, U4 und U8), nicht verwalteter Typen, die in der .NET Framework nicht verfügbar sind, und verschiedener Typen zu Mars Hallen.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.

Weitere Informationen finden Sie unter Interoperation mit nicht verwaltetem Code.For more information, see Interoperating with Unmanaged Code.

Gilt für:

Siehe auch