UnmanagedType Výčet

Definice

Označuje způsob zařazení parametrů nebo polí do nespravovaného kódu.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
Dědičnost
UnmanagedType
Atributy

Pole

AnsiBStr 35

Řetězec znaků ANSI, který je délkou předpony s jedním pevným bajtem.An ANSI character string that is a length-prefixed single byte. Tento člen můžete použít pro String datový typ.You can use this member on the String data type.

AsAny 40

Dynamický typ, který určuje typ objektu v době běhu a zařazuje objekt jako tento typ.A dynamic type that determines the type of an object at run time and marshals the object as that type. Tento člen je platný pouze pro metody vyvolání platformy.This member is valid for platform invoke methods only.

Bool 2

Logická hodnota o velikosti 4 bajty (true ! = 0, false = 0).A 4-byte Boolean value (true != 0, false = 0). Toto je typ BOOL typu Win32.This is the Win32 BOOL type.

BStr 19

Řetězec znaků Unicode, který je délkou s předponou, která je typu Double.A Unicode character string that is a length-prefixed double byte. Tento člen, který je výchozím řetězcem v modelu COM, lze použít pro String datový typ.You can use this member, which is the default string in COM, on the String data type.

ByValArray 30

Pokud je ByValArrayvlastnost nastavena na hodnotu, SizeConst musí být pole nastaveno na hodnotu určující počet prvků v poli. ValueWhen the Value property is set to ByValArray, the SizeConst field must be set to indicate the number of elements in the array. Pole může volitelně UnmanagedType obsahovat prvky pole, když je nutné rozlišovat mezi typy řetězců. ArraySubTypeThe ArraySubType field can optionally contain the UnmanagedType of the array elements when it is necessary to differentiate among string types. Tuto UnmanagedType možnost lze použít pouze v poli, jehož prvky se zobrazí jako pole ve struktuře.You can use this UnmanagedType only on an array that whose elements appear as fields in a structure.

ByValTStr 23

Používá se pro znaková pole s pevnou délkou, která se zobrazují v rámci struktury.Used for in-line, fixed-length character arrays that appear within a structure. ByValTStrtypy se chovají jako řetězce s pevnou velikostí v rámci struktury, jako je ve stylu jazyka C (například char s [5]).ByValTStr types behave like C-style, fixed-size strings inside a structure (for example, char s[5]). Typ znaku používaný ByValTStr pro je určen CharSet argumentem StructLayoutAttribute atributu použitým pro nadřazenou strukturu.The character type used with ByValTStr is determined by the CharSet argument of the StructLayoutAttribute attribute applied to the containing structure. Vždy použijte SizeConst pole k označení velikosti pole.Always use the SizeConst field to indicate the size of the array.

Currency 15

Typ měny.A currency type. Používá se pro zařazování desítkové hodnoty jako typ měny com namísto Decimaljako. DecimalUsed on a Decimal to marshal the decimal value as a COM currency type instead of as a Decimal.

CustomMarshaler 44

Určuje vlastní třídu zařazovacího modulu při použití s MarshalType polem MarshalTypeRef or.Specifies the custom marshaler class when used with the MarshalType or MarshalTypeRef field. MarshalCookie Pole lze použít k předání dalších informací do vlastního zařazovacího modulu.The MarshalCookie field can be used to pass additional information to the custom marshaler. Tento člen můžete použít na jakémkoli typu odkazu.You can use this member on any reference type. Tento člen je platný pouze pro parametry a návratové hodnoty.This member is valid for parameters and return values only. Nelze jej použít pro pole.It cannot be used on fields.

Error 45

Nativní typ, který je spojen s I4 U4 nebo a způsobuje, že parametr bude exportován jako HRESULT v exportované knihovně typů.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 38

Celé číslo, které lze použít jako ukazatel na funkci ve stylu jazyka C.An integer that can be used as a C-style function pointer. Tento člen můžete použít pro Delegate datový typ nebo pro typ, který dědí Delegatez.You can use this member on a Delegate data type or on a type that inherits from a Delegate.

HString 47

prostředí Windows RuntimeWindows Runtime Řetězec.A prostředí Windows RuntimeWindows Runtime string. Tento člen můžete použít pro String datový typ.You can use this member on the String data type.

I1 3

Dvoubajtové celé číslo se znaménkem 1.A 1-byte signed integer. Tento člen můžete použít k transformaci logické hodnoty na 1 bajt, styl bool 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 5

Celé číslo se znaménkem na 2 bajt.A 2-byte signed integer.

I4 7

Celé číslo se znaménkem na 4 bajty.A 4-byte signed integer.

I8 9

8bitové celé číslo se znaménkem na 8 bajtů.An 8-byte signed integer.

IDispatch 26

Ukazatel modelu IDispatch com (Object v Microsoft Visual Basic 6,0).A COM IDispatch pointer (Object in Microsoft Visual Basic 6.0).

IInspectable 46

Ukazatel prostředí Windows RuntimeWindows Runtime rozhraní.A prostředí Windows RuntimeWindows Runtime interface pointer. Tento člen můžete použít pro Object datový typ.You can use this member on the Object data type.

Interface 28

Ukazatel rozhraní modelu COM.A COM interface pointer. Guid Rozhraní je získáno z metadat třídy.The Guid of the interface is obtained from the class metadata. Tento člen slouží k určení přesného typu rozhraní nebo výchozího typu rozhraní, pokud jej použijete pro třídu.Use this member to specify the exact interface type or the default interface type if you apply it to a class. Tento člen vytvoří stejné chování jako IUnknown při použití Object pro datový typ.This member produces the same behavior as IUnknown when you apply it to the Object data type.

IUnknown 25

Ukazatel modelu IUnknown com.A COM IUnknown pointer. Tento člen můžete použít pro Object datový typ.You can use this member on the Object data type.

LPArray 42

Ukazatel na první prvek pole ve stylu jazyka C.A pointer to the first element of a C-style array. Při zařazování ze spravovaného do nespravovaného kódu je délka pole určena délkou spravovaného pole.When marshaling from managed to unmanaged code, the length of the array is determined by the length of the managed array. Při zařazování z nespravovaného do spravovaného kódu je délka pole určena z SizeConst polí a SizeParamIndex , volitelně následováno nespravovaným typem prvků v poli, pokud je to nutné pro rozlišení řetězce. druhy.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 20

Jeden bajtový řetězec znaků ve formátu ANSI zakončený hodnotou null.A single byte, null-terminated ANSI character string. Tento člen můžete použít pro String datové typy a. StringBuilderYou can use this member on the String and StringBuilder data types.

LPStruct 43

Ukazatel na strukturu ve stylu jazyka C, kterou používáte k zařazování spravovaných formátovaných tříd.A pointer to a C-style structure that you use to marshal managed formatted classes. Tento člen je platný pouze pro metody vyvolání platformy.This member is valid for platform invoke methods only.

LPTStr 22

Řetězec znaků závislých na platformě: ANSI v systémech Windows 98 a Unicode v systémech Windows NT a Windows XP.A platform-dependent character string: ANSI on Windows 98, and Unicode on Windows NT and Windows XP. Tato hodnota je podporována pouze pro vyvolání platformy, nikoli pro zprostředkovatele komunikace s objekty COM, protože export řetězce LPTStr typu není podporován.This value is supported only for platform invoke and not for COM interop, because exporting a string of type LPTStr is not supported.

LPUTF8Str 48

Ukazatel na řetězec kódovaný v kódování UTF-8.A pointer to a UTF-8 encoded string.

LPWStr 21

Řetězec znaků Unicode zakončený hodnotou null.A 2-byte, null-terminated Unicode character string. Nelze použít LPWStr hodnotu s nespravovaným řetězcem, pokud byl řetězec vytvořen pomocí nespravované CoTaskMemAlloc funkce.You cannot use the LPWStr value with an unmanaged string unless the string was created by using the unmanaged CoTaskMemAlloc function.

R4 11

Číslo s plovoucí desetinnou čárkou o velikosti 4 bajty.A 4-byte floating-point number.

R8 12

Číslo s plovoucí desetinnou čárkou a 8 bajty.An 8-byte floating-point number.

SafeArray 29

SafeArray, Což je samo popisující pole, které slouží jako typ, pořadí a meze přidružených dat pole.A SafeArray, which is a self-describing array that carries the type, rank, and bounds of the associated array data. Pomocí tohoto člena s SafeArraySubType polem můžete přepsat výchozí typ prvku.You can use this member with the SafeArraySubType field to override the default element type.

Struct 27

TYP VARIANT, který se používá k zařazování spravovaných formátovaných tříd a hodnotových typů.A VARIANT, which is used to marshal managed formatted classes and value types.

SysInt 31

Celé číslo se znaménkem závislé na platformě: 4 bajty v 32 bitovém systému Windows, 8 bajtů v 64 bitovém systému Windows.A platform-dependent, signed integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

SysUInt 32

Unsigned integer závislých na platformě: 4 bajty v 32 bitovém systému Windows, 8 bajtů v 64 bitovém systému Windows.A platform-dependent, unsigned integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.

TBStr 36

Délka předpony, která je závislá char na platformě: ANSI v systému Windows 98, Unicode v systému Windows NT.A length-prefixed, platform-dependent char string: ANSI on Windows 98, Unicode on Windows NT. Tento člen podobný tomuto typu BSTR se používá jen zřídka.You rarely use this BSTR-like member.

U1 4

Unsigned integer o velikosti 1 bajtu.A 1-byte unsigned integer.

U2 6

2 bajt unsigned integer.A 2-byte unsigned integer.

U4 8

Unsigned integer o velikosti 4 bajty.A 4-byte unsigned integer.

U8 10

Unsigned integer o velikosti 8 bajtů.An 8-byte unsigned integer.

VariantBool 37

2 bajtový typ VARIANT_BOOL definovaný OLE (true =-1, false = 0).A 2-byte, OLE-defined VARIANT_BOOL type (true = -1, false = 0).

VBByRefStr 34

Hodnota, která umožňuje Visual Basic změnit řetězec v nespravovaném kódu a výsledky se projeví ve spravovaném kódu.A value that enables Visual Basic to change a string in unmanaged code and have the results reflected in managed code. Tato hodnota je podporována pouze pro vyvolání platformy.This value is only supported for platform invoke.

Příklady

Následující fragment kódu ukazuje, jak deklarovat, ve spravovaném zdrojovém kódu, nespravované rozhraní implementované komponentou modelu COM.The following code fragment demonstrates how to declare, in managed source code, an unmanaged interface implemented by a COM component. System.Runtime.InteropServices.ComImportAttribute Atribut bráníexporturozhranízpětproIMyStorage použití v modelu COM.The System.Runtime.InteropServices.ComImportAttribute attribute prevents the IMyStorage interface from being exported back for use by COM. (Klienti modelu COM by měli používat existující komponentu COM přímo.) V tomto příkladu MarshalAsAttribute určuje několik UnmanagedType členů, které reprezentují typy používané původním rozhraním com.(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.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

Poznámky

UnmanagedType Použijte výčet System.Runtime.InteropServices.MarshalAsAttribute s atributem k určení toho, jak jsou typy zařazeny během spolupráce s nespravovaným kódem.Use the UnmanagedType enumeration with the System.Runtime.InteropServices.MarshalAsAttribute attribute to specify how types are marshaled during interoperation with unmanaged code. Tento výčet můžete použít k zařazení kódu s použitím jednoduchých hodnotových typů (typem I1, I2, i4, i8, R4, R8, U2, U4 a U8), nespravovaných typů, které nejsou k dispozici v .NET Framework a různých různých typů.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.

Další informace najdete v tématu spolupráce s nespravovaným kódem.For more information, see Interoperating with Unmanaged Code.

Platí pro

Viz také