UnmanagedMarshal Classe

Définition

Avertissement

Cette API est désormais obsolète.

Représente la classe qui décrit comment marshaler un champ d'un code managé à un code non managé.Represents the class that describes how to marshal a field from managed to unmanaged code. Cette classe ne peut pas être héritée.This class cannot be inherited.

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

Exemples

L’exemple de code suivant montre le code de remplacement pour le type de UnmanagedMarshal obsolète.The following code example shows replacement code for the obsolete UnmanagedMarshal type. L’exemple émet un assembly à module unique nommé EmitMarshalAs.dll, contenant un type nommé Sample.The example emits a single-module assembly named EmitMarshalAs.dll, containing a type named Sample. Le type a une méthode nommée Test, avec un paramètre de type String.The type has a method named Test, with one parameter of type String. L’exemple de code applique la MarshalAsAttribute avec UnmanagedType.BStr au paramètre.The code example applies the MarshalAsAttribute with UnmanagedType.BStr to the parameter.

Vous pouvez utiliser Ildasm. exe (Désassembleur il) pour examiner l’assembly émis et observer que le paramètre est marqué marshal(bstr).You can use the Ildasm.exe (IL Disassembler) to examine the emitted assembly and observe that the parameter is marked 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 illustre la solution de contournement pour ce type obsolète.The code example shows the workaround for this obsolete type.

Le marshaling est le processus d’empaquetage et d’empaquetage des paramètres pour que des appels de procédure distante puissent se produire.Marshaling is the process of packaging and unpackaging parameters so remote procedure calls can occur. 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.During marshaling, a field might undergo a format conversion when the format of the managed type is different from the format of the corresponding unmanaged type. Par exemple, vous souhaiterez peut-être marshaler un type de String en tant que BSTR non managé.For example, you might want to marshal a String type as an unmanaged BSTR. Certaines conversions de format sont gérées automatiquement par le Runtime.Some format conversions are handled automatically by the runtime. Pour remplacer le comportement par défaut, vous devez utiliser la classe UnmanagedMarshal pour définir la conversion de format.To override the default behavior, you must use the UnmanagedMarshal class to define the format conversion.

Propriétés

BaseType

Obtient un type de base non managé.Gets an unmanaged base type. Cette propriété est en lecture seule.This property is read-only.

ElementCount

Obtient un élément numérique.Gets a number element. Cette propriété est en lecture seule.This property is read-only.

GetUnmanagedType

Indique un type non managé.Indicates an unmanaged type. Cette propriété est en lecture seule.This property is read-only.

IIDGuid

Obtient un GUID.Gets a GUID. Cette propriété est en lecture seule.This property is read-only.

Méthodes

DefineByValArray(Int32)

Spécifie un tableau de longueur fixe (ByValArray) à marshaler en code non managé.Specifies a fixed-length array (ByValArray) to marshal to unmanaged code.

DefineByValTStr(Int32)

Spécifie une chaîne dans une mémoire tampon de tableau de longueur fixe (ByValTStr) à marshaler en code non managé.Specifies a string in a fixed array buffer (ByValTStr) to marshal to unmanaged code.

DefineLPArray(UnmanagedType)

Spécifie un LPArray à marshaler en code non managé.Specifies an LPArray to marshal to unmanaged code. La longueur d'un LPArray est déterminée par la taille du tableau réellement marshalé au moment de l'exécution.The length of an LPArray is determined at runtime by the size of the actual marshaled array.

DefineSafeArray(UnmanagedType)

Spécifie un SafeArray à marshaler en code non managé.Specifies a SafeArray to marshal to unmanaged code.

DefineUnmanagedMarshal(UnmanagedType)

Spécifie un type donné à marshaler en code non managé.Specifies a given type that is to be marshaled to unmanaged code.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)

S’applique à

Voir aussi