UnmanagedType-Enumeration

Artikel
08/20/2007

Gibt an, wie Parameter oder Felder in nicht verwaltetem Code gemarshallt werden.

Namespace: System.Runtime.InteropServices
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Enumeration UnmanagedType
'Usage
Dim instance As UnmanagedType

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

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

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public enum UnmanagedType

SerializableAttribute 
ComVisibleAttribute(true) 
public enum UnmanagedType

Member

	Membername	Beschreibung
	AnsiBStr	Eine Zeichenfolge aus ANSI-Zeichen, die ein Einzelbyte mit Längenpräfix ist. Sie können diesen Member für den String-Datentyp verwenden.
	AsAny	Ein dynamischer Typ, der zur Laufzeit den Typ eines Objekts bestimmt und das Objekt als diesen Typ marshallt. Nur gültig für Plattformaufruf-Methoden.
	Bool	Ein boolescher Wert mit 4 Bytes (true != 0, false = 0). Dies ist der Win32-BOOL-Typ.
	BStr	Eine Zeichenfolge aus Unicode-Zeichen, die ein Doppelbyte mit Längenpräfix ist. Sie können diesen Member, der die Standardzeichenfolge in COM darstellt, für den String-Datentyp verwenden.
	ByValArray	Wenn MarshalAsAttribute.Value auf ByValArray festgelegt wird, muss SizeConst so festgelegt werden, dass die Anzahl der Elemente im Array angegeben wird. Das ArraySubType-Feld kann optional den UnmanagedType der Arrayelemente enthalten, wenn zwischen verschiedenen Zeichenfolgetypen unterschieden werden muss. Sie können diesen UnmanagedType nur für ein Array verwenden, das in einer Struktur in Form von Feldern angezeigt wird.
	ByValTStr	Wird für Inlinearrays mit Zeichen fester Länge verwendet, die in einer Struktur dargestellt werden. Der in ByValTStr verwendete Zeichentyp wird durch das System.Runtime.InteropServices.CharSet-Argument des System.Runtime.InteropServices.StructLayoutAttribute bestimmt, das auf die enthaltende Struktur angewendet wird. Verwenden Sie immer das MarshalAsAttribute.SizeConst-Feld, um die Größe des Arrays anzugeben. ByValTStr-Typen von .NET Framework verhalten sich in einer Struktur wie C-Zeichenfolgen mit fester Länge (beispielsweise `char s[5]`). Das Verhalten in verwaltetem Code weicht vom Verhalten in Microsoft Visual Basic 6.0 ab, das nicht nullterminiert ist (beispielsweise `MyString As String * 5`).
	Currency	Wird für System.Decimal verwendet, um den Dezimalwert als COM-Währungstyp und nicht alsDecimal zu marshallen.
	CustomMarshaler	Gibt bei Verwendung mit MarshalAsAttribute.MarshalType oder MarshalAsAttribute.MarshalTypeRef die benutzerdefinierte Marshaller-Klasse an. Das Feld MarshalAsAttribute.MarshalCookie kann zum Übergeben zusätzlicher Informationen an den benutzerdefinierten Marshaller verwendet werden. Sie können diesen Member für beliebige Verweistypen verwenden.
	Error	Dieser mit einem I4 oder einem U4 verknüpfte systemeigene Typ bewirkt, dass der Parameter als ein HRESULT in die Bibliothek mit den Exporttypen exportiert wird.
	FunctionPtr	Eine Ganzzahl, die als C-Funktionszeiger verwendet werden kann. Sie können diesen Member für einen Delegate-Datentyp oder einen Typ verwenden, der von einem Delegate erbt.
	I1	Eine 1-Byte-Ganzzahl mit Vorzeichen. Sie können mit diesem Member einen booleschen Wert in einen 1-Byte-bool im C-Format (true = 1, false = 0) transformieren.
	I2	Eine 2-Byte-Ganzzahl mit Vorzeichen.
	I4	Eine 4-Byte-Ganzzahl mit Vorzeichen.
	I8	Eine 8-Byte-Ganzzahl mit Vorzeichen.
	IDispatch	Ein IDispatch-Zeiger in COM (Object in Microsoft Visual Basic 6.0).
	Interface	Ein COM-Schnittstellenzeiger. Die Guid der Schnittstelle wird aus den Metadaten der Klasse ermittelt. Mit diesem Member geben Sie den genauen Schnittstellentyp oder den Standardschnittstellentyp an, wenn Sie ihn auf eine Klasse anwenden. Dieser Member bewirkt UnmanagedType.IUnknown-Verhalten, wenn sie ihn auf den Object-Datentyp anwenden.
	IUnknown	Ein COM-IUnknown-Zeiger. Sie können diesen Member für den Object-Datentyp verwenden.
	LPArray	Ein Zeiger auf das erste Element eines C-Arrays. Beim Marshallen von verwaltet zu nicht verwaltet wird die Länge des Arrays anhand der Länge desverwalteten Arrays bestimmt. Beim Marshallen von nicht verwaltetem in verwalteten Code wird die Länge des Arrays vom MarshalAsAttribute.SizeConst-Feld und vom MarshalAsAttribute.SizeParamIndex-Feld bestimmt, auf die optional der nicht verwaltete Typ der Elemente im Array folgt, wenn eine Unterscheidung zwischen Zeichenfolgentypen erforderlich ist.
	LPStr	Eine aus ANSI-Zeichen bestehende, mit NULL beendete Einzelbyte-Zeichenfolge. Sie können diesen Member für den System.String-Datentyp oder den System.Text.StringBuilder-Datentyp verwenden.
	LPStruct	Ein Zeiger auf eine C-Struktur, mit dem verwaltete formatierte Klassen gemarshallt werden. Nur gültig für Plattformaufruf-Methoden.
	LPTStr	Eine plattformabhängige Zeichenfolge, d. h. ANSI unter Windows 98 und Unicode unter Windows NT und 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.
	LPWStr	Eine aus Unicode-Zeichen bestehende, mit NULL beendete 2-Byte-Zeichenfolge. Beachten Sie, dass der LPWStr-Wert nicht mit einer nicht verwalteten Zeichenfolge verwendet werden kann, es sei denn, diese wurde mithilfe der nicht verwalteten CoTaskMemAlloc-Funktion erstellt.
	R4	Eine 4-Byte-Gleitkommazahl.
	R8	Eine 8-Byte-Gleitkommazahl.
	SafeArray	Ein SafeArray ist ein selbstbeschreibendes Array mit dem Typ, dem Rang und den Grenzen der verknüpften Arraydaten. Sie können diesen Member mit dem MarshalAsAttribute.SafeArraySubType-Feld verwenden, um den Standardelementtyp zu überschreiben.
	Struct	Ein VARIANT zum Marshallen verwalteter formatierter Klassen und Werttypen.
	SysInt	Eine plattformabhängige Ganzzahl mit Vorzeichen. 4 Byte für 32-Bit-Windows, 8 Byte für 64-Bit-Windows.
	SysUInt	Eine plattformabhängige Ganzzahl ohne Vorzeichen. 4 Byte für 32-Bit-Windows, 8 Byte für 64-Bit-Windows.
	TBStr	Eine plattformabhängige char-Zeichenfolge mit Längenpräfix. ANSI für Windows 98 bzw. Unicode für Windows NT. Dieser BSTR-ähnliche Member wird nur selten verwendet.
	U1	Eine 1-Byte-Ganzzahl ohne Vorzeichen.
	U2	Eine 2-Byte-Ganzzahl ohne Vorzeichen.
	U4	Eine 4-Byte-Ganzzahl ohne Vorzeichen.
	U8	Eine 8-Byte-Ganzzahl ohne Vorzeichen.
	VariantBool	Ein durch OLE definierter VARIANT_BOOL-Typ mit 2 Bytes (true = -1, false = 0).
	VBByRefStr	Ermöglicht Visual Basic 2005 das Ändern einer Zeichenfolge in nicht verwaltetem Code und die Wiedergabe der Ergebnisse in verwaltetem Code. Dieser Wert wird nur für Plattformaufrufe unterstützt.

Hinweise

Verwenden Sie die UnmanagedType-Enumeration mit dem System.Runtime.InteropServices.MarshalAsAttribute, um anzugeben, wie Typen während der Interoperation mit nicht verwaltetem Code gemarshallt werden. Sie können diese Enumeration auch zum Marshallen von Code mithilfe einfacher Werttypen (I1, I2, I4, I8, R4, R8, U2, U4 und U8), nicht verwalteter, im .NET Framework nicht verfügbarer Typen und einer Reihe sonstiger Typen verwenden.

Weitere Informationen finden Sie unter Interoperation mit nicht verwaltetem Code.

Beispiel

Mit dem folgenden Codefragment wird die Deklaration einer nicht verwalteten Schnittstelle in verwaltetem Quellcode veranschaulicht, die von einer COM-Komponente implementiert wird. System.Runtime.InteropServices.ComImportAttribute verhindert, dass die IMyStorage-Schnittstelle wieder für die Verwendung durch COM exportiert wird. (COM-Clients sollten die vorhandene COM-Komponente direkt verwenden.) In diesem Beispiel werden mit MarshalAsAttribute mehrere UnmanagedType-Member angegeben, die die von der ursprünglichen COM-Schnittstelle verwendeten Typen darstellen.

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)> 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 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;
        }
    }
}

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();
   }
};

import System.*;
import 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.
    /** @attribute ComImport()
     */
    /** @attribute Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")
     */
   public interface IMyStorage
   {
        /** @attribute DispId(1)
         */
        Object GetItem(
        /** @attribute In()
            @attribute MarshalAs(UnmanagedType.BStr)
         */String bstrName);
      
      
        /** @attribute DispId(2)
         */
        void GetItems(
        /** @attribute In()
            @attribute MarshalAs(UnmanagedType.BStr)
         */String bstrLocation,
        /** @attribute Out()
            @attribute MarshalAs(UnmanagedType.SafeArray, 
            SafeArraySubType = VarEnum.VT_VARIANT)
         */Object Items[]);
             
        /** @attribute DispId(3)
         */
        void GetItemDescriptions(
            /** @attribute In()
             */String bstrLocation,
            /** @attribute In()
                @attribute Out()
                @attribute MarshalAs(UnmanagedType.SafeArray)
             */Object varDescriptions[]);
               
        /** @attribute DispId(4)
         */
        /** @return MarshalAs(UnmanagedType.VariantBool)
         */
        boolean get_IsEmpty();
    } //IMyStorage

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

System.Runtime.InteropServices-Namespace
MarshalAsAttribute-Klasse
ComImportAttribute-Klasse

Freigeben über