UnmanagedMarshal Classe

Référence

Définition

Espace de noms:: System.Reflection.Emit

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Attention

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

Représente la classe qui décrit comment marshaler un champ d'un code managé à un code non managé. Cette classe ne peut pas être héritée.

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

Héritage: Object
UnmanagedMarshal

Attributs: SerializableAttribute ObsoleteAttribute ComVisibleAttribute

Exemples

L’exemple de code suivant montre le code de remplacement pour le type obsolète UnmanagedMarshal . L’exemple émet un assembly à module unique nommé EmitMarshalAs.dll, contenant un type nommé Sample. Le type a une méthode nommée Test, avec un paramètre de type String. L’exemple de code applique le MarshalAsAttribute avec UnmanagedType.BStr au paramètre .

Vous pouvez utiliser le Ildasm.exe (désassembleur IL) pour examiner l’assembly émis et observer que le paramètre est marqué marshal(bstr).

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

Remarques

L’exemple de code montre la solution de contournement pour ce type obsolète.

Le marshaling est le processus d’empaquetage et de décompression des paramètres afin que des appels de procédure distante puissent se produire. Pendant le marshaling, un champ peut subir une conversion de format lorsque le format du type managé est différent du format du type non managé correspondant. Par exemple, vous pouvez marshaler un String type en tant que BSTR non managé. Certaines conversions de format sont gérées automatiquement par le runtime. Pour remplacer le comportement par défaut, vous devez utiliser la UnmanagedMarshal classe pour définir la conversion de format.

Propriétés

BaseType	Obsolète. Obtient un type de base non managé. Cette propriété est en lecture seule.
ElementCount	Obsolète. Obtient un élément numérique. Cette propriété est en lecture seule.
GetUnmanagedType	Obsolète. Indique un type non managé. Cette propriété est en lecture seule.
IIDGuid	Obsolète. Obtient un GUID. Cette propriété est en lecture seule.

Méthodes

DefineByValArray(Int32)	Obsolète. Spécifie un tableau de longueur fixe (ByValArray) à marshaler en code non managé.
DefineByValTStr(Int32)	Obsolète. Spécifie une chaîne dans une mémoire tampon de tableau de longueur fixe (ByValTStr) à marshaler en code non managé.
DefineLPArray(UnmanagedType)	Obsolète. Spécifie un `LPArray` à marshaler en code non managé. La longueur d'un `LPArray` est déterminée par la taille du tableau réellement marshalé au moment de l'exécution.
DefineSafeArray(UnmanagedType)	Obsolète. Spécifie un `SafeArray` à marshaler en code non managé.
DefineUnmanagedMarshal(UnmanagedType)	Obsolète. Spécifie un type donné à marshaler en code non managé.
Equals(Object)	Obsolète. Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Obsolète. Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obsolète. Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Obsolète. Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Obsolète. Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

S’applique à

Partager via