UnmanagedMarshal Klasse

Referenz

Definition

Namespace:: System.Reflection.Emit

Assembly:: mscorlib.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Achtung

An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202

Stellt die Klasse dar, die das Marshallen eines Felds von verwaltetem zu nicht verwaltetem Code beschreibt. Diese Klasse kann nicht vererbt werden.

public ref class UnmanagedMarshal sealed

[System.Serializable]
public sealed class UnmanagedMarshal

[System.Serializable]
[System.Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class UnmanagedMarshal

[<System.Serializable>]
type UnmanagedMarshal = class

[<System.Serializable>]
[<System.Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type UnmanagedMarshal = class

Public NotInheritable Class UnmanagedMarshal

Vererbung: Object
UnmanagedMarshal

Attribute: SerializableAttribute ObsoleteAttribute ComVisibleAttribute

Beispiele

Das folgende Codebeispiel zeigt Ersatzcode für den veralteten UnmanagedMarshal Typ. Im Beispiel wird eine Einzelne-Modulassembly mit dem Namen EmitMarshalAs.dllausgegeben, die einen Typ namens enthält Sample. Der Typ verfügt über eine Methode namens Testmit einem Parameter vom Typ String. Im Codebeispiel wird mit MarshalAsAttribute UnmanagedType.BStr auf den Parameter angewendet.

Sie können den Ildasm.exe (IL Disassembler) verwenden, um die ausgegebene Assembly zu untersuchen und zu beobachten, dass der Parameter als gekennzeichnet marshal(bstr)ist.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Runtime::InteropServices;

void main()
{
    AppDomain^ myDomain = AppDomain::CurrentDomain;
    AssemblyName^ myAsmName = gcnew AssemblyName("EmitMarshalAs");

    AssemblyBuilder^ myAssembly = 
        myDomain->DefineDynamicAssembly(myAsmName, 
            AssemblyBuilderAccess::RunAndSave);

    ModuleBuilder^ myModule = 
        myAssembly->DefineDynamicModule(myAsmName->Name, 
            myAsmName->Name + ".dll");
 
    TypeBuilder^ myType = 
        myModule->DefineType("Sample", TypeAttributes::Public);

    MethodBuilder^ myMethod = 
        myType->DefineMethod("Test", MethodAttributes::Public,
            nullptr, gcnew array<Type^> { String::typeid });


    // Get a parameter builder for the parameter that needs the 
    // attribute, using the HasFieldMarshal attribute. In this
    // example, the parameter is at position 0 and has the name
    // "arg".
    ParameterBuilder^ pb = 
        myMethod->DefineParameter(0, 
            ParameterAttributes::HasFieldMarshal, "arg");

    // Get the MarshalAsAttribute constructor that takes an
    // argument of type UnmanagedType.
    //
    //Type^ maattrType = MarshalAsAttribute::typeid;
    ConstructorInfo^ ci = 
        (MarshalAsAttribute::typeid)->GetConstructor(
            gcnew array<Type^> { UnmanagedType::typeid });

    // Create a CustomAttributeBuilder representing the attribute,
    // specifying the necessary unmanaged type. In this case, 
    // UnmanagedType.BStr is specified.
    //
    CustomAttributeBuilder^ cabuilder = 
        gcnew CustomAttributeBuilder(
            ci, gcnew array<Object^> { UnmanagedType::BStr });

    // Apply the attribute to the parameter.
    //
    pb->SetCustomAttribute(cabuilder);


    ILGenerator^ il = myMethod->GetILGenerator();
    il->Emit(OpCodes::Ret);

    Type^ finished = myType->CreateType();
    myAssembly->Save(myAsmName->Name + ".dll");
}

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;

public class Example
{
    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new AssemblyName("EmitMarshalAs");

        AssemblyBuilder myAssembly =
            myDomain.DefineDynamicAssembly(myAsmName,
                AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder myModule =
            myAssembly.DefineDynamicModule(myAsmName.Name,
               myAsmName.Name + ".dll");

        TypeBuilder myType =
            myModule.DefineType("Sample", TypeAttributes.Public);

        MethodBuilder myMethod =
            myType.DefineMethod("Test", MethodAttributes.Public,
                null, new Type[] { typeof(string) });

        // Get a parameter builder for the parameter that needs the
        // attribute, using the HasFieldMarshal attribute. In this
        // example, the parameter is at position 0 and has the name
        // "arg".
        ParameterBuilder pb =
            myMethod.DefineParameter(0,
               ParameterAttributes.HasFieldMarshal, "arg");

        // Get the MarshalAsAttribute constructor that takes an
        // argument of type UnmanagedType.
        //
        ConstructorInfo ci =
            typeof(MarshalAsAttribute).GetConstructor(
                new Type[] { typeof(UnmanagedType) });

        // Create a CustomAttributeBuilder representing the attribute,
        // specifying the necessary unmanaged type. In this case,
        // UnmanagedType.BStr is specified.
        //
        CustomAttributeBuilder cabuilder =
            new CustomAttributeBuilder(
                ci, new object[] { UnmanagedType.BStr });

        // Apply the attribute to the parameter.
        //
        pb.SetCustomAttribute(cabuilder);

        // Emit a dummy method body.
        ILGenerator il = myMethod.GetILGenerator();
        il.Emit(OpCodes.Ret);

        Type finished = myType.CreateType();
        myAssembly.Save(myAsmName.Name + ".dll");
    }
}

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Runtime.InteropServices

Public Class Example

    Public Shared Sub Main()

        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("EmitMarshalAs")

        Dim myAssembly As AssemblyBuilder = _
            myDomain.DefineDynamicAssembly(myAsmName, _
                AssemblyBuilderAccess.RunAndSave)

        Dim myModule As ModuleBuilder = _
            myAssembly.DefineDynamicModule(myAsmName.Name, _
                myAsmName.Name & ".dll")

        Dim myType As TypeBuilder = _
            myModule.DefineType("Sample", TypeAttributes.Public)
        
        Dim myMethod As MethodBuilder = _
            myType.DefineMethod("Test", MethodAttributes.Public, _
                Nothing, new Type() { GetType(String) })


        ' Get a parameter builder for the parameter that needs the 
        ' attribute, using the HasFieldMarshal attribute. In this
        ' example, the parameter is at position 0 and has the name
        ' "arg".
        Dim pb As ParameterBuilder = _
            myMethod.DefineParameter(0, _
               ParameterAttributes.HasFieldMarshal, "arg")

        ' Get the MarshalAsAttribute constructor that takes an
        ' argument of type UnmanagedType.
        '
        Dim ciParameters() As Type = { GetType(UnmanagedType) }
        Dim ci As ConstructorInfo = _
            GetType(MarshalAsAttribute).GetConstructor(ciParameters)

        ' Create a CustomAttributeBuilder representing the attribute,
        ' specifying the necessary unmanaged type. In this case, 
        ' UnmanagedType.BStr is specified.
        '
        Dim ciArguments() As Object = { UnmanagedType.BStr }
        Dim cabuilder As New CustomAttributeBuilder(ci, ciArguments)

        ' Apply the attribute to the parameter.
        '
        pb.SetCustomAttribute(cabuilder)


        ' Emit a dummy method body.
        Dim il As ILGenerator = myMethod.GetILGenerator()
        il.Emit(OpCodes.Ret)

        myType.CreateType()
        myAssembly.Save(myAsmName.Name & ".dll")

    End Sub

End Class

Hinweise

Das Codebeispiel zeigt die Problemumgehung für diesen veralteten Typ.

Marshalling ist der Prozess des Verpackens und Entpackens von Parametern, damit Remoteprozeduraufrufe erfolgen können. Während des Marshallings kann ein Feld einer Formatkonvertierung unterzogen werden, wenn sich das Format des verwalteten Typs vom Format des entsprechenden nicht verwalteten Typs unterscheidet. Beispielsweise können Sie einen String Typ als nicht verwalteten BSTR marshallen. Einige Formatkonvertierungen werden automatisch von der Runtime verarbeitet. Um das Standardverhalten zu überschreiben, müssen Sie die UnmanagedMarshal -Klasse verwenden, um die Formatkonvertierung zu definieren.

Eigenschaften

BaseType	Veraltet. Ruft einen nicht verwalteten Basistyp ab. Diese Eigenschaft ist schreibgeschützt.
ElementCount	Veraltet. Ruft ein Zahlenelement ab. Diese Eigenschaft ist schreibgeschützt.
GetUnmanagedType	Veraltet. Gibt einen nicht verwalteten Typ an. Diese Eigenschaft ist schreibgeschützt.
IIDGuid	Veraltet. Ruft eine GUID ab. Diese Eigenschaft ist schreibgeschützt.

Methoden

DefineByValArray(Int32)	Veraltet. Gibt ein Array fester Länge (ByValArray) an, das zu nicht verwaltetem Code gemarshallt werden soll.
DefineByValTStr(Int32)	Veraltet. Gibt eine in einem Puffer für ein feststehendes Array enthaltene Zeichenfolge (ByValTStr) an, das zu nicht verwaltetem Code gemarshallt werden soll.
DefineLPArray(UnmanagedType)	Veraltet. Gibt ein `LPArray` an, das zu nicht verwaltetem Code gemarshallt werden soll. Die Länge eines `LPArray` wird zur Laufzeit von der Größe des tatsächlich gemarshallten Arrays bestimmt.
DefineSafeArray(UnmanagedType)	Veraltet. Gibt ein `SafeArray` an, das zu nicht verwaltetem Code gemarshallt werden soll.
DefineUnmanagedMarshal(UnmanagedType)	Veraltet. Gibt einen angegebenen Typ an, der zu nicht verwaltetem Code gemarshallt werden soll.
Equals(Object)	Veraltet. Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Veraltet. Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Veraltet. Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Veraltet. Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Veraltet. Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Gilt für: