Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase UnmanagedMarshal

 

Publicado: octubre de 2016

Nota: Esta API ahora está obsoleta.

Representa la clase que describe cómo convertir un campo de código administrado a código no administrado. Esta clase no puede heredarse.

Espacio de nombres:   System.Reflection.Emit
Ensamblado:  mscorlib (en mscorlib.dll)

System.Object
  System.Reflection.Emit.UnmanagedMarshal

[SerializableAttribute]
[ComVisibleAttribute(true)]
[ObsoleteAttribute("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
[HostProtectionAttribute(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
public sealed class UnmanagedMarshal

NombreDescripción
System_CAPS_pubpropertyBaseType

Obtiene un tipo base no administrado. Esta propiedad es de sólo lectura.

System_CAPS_pubpropertyElementCount

Obtiene un elemento numérico. Esta propiedad es de sólo lectura.

System_CAPS_pubpropertyGetUnmanagedType

Indica un tipo no administrado. Esta propiedad es de sólo lectura.

System_CAPS_pubpropertyIIDGuid

Obtiene un GUID. Esta propiedad es de sólo lectura.

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticDefineByValArray(Int32)

Especifica una matriz de longitud fija (ByValArray) para calcular las referencias a código no administrado.

System_CAPS_pubmethodSystem_CAPS_staticDefineByValTStr(Int32)

Especifica una cadena en un búfer de matriz fija (ByValTStr) para calcular las referencias a código no administrado.

System_CAPS_pubmethodSystem_CAPS_staticDefineLPArray(UnmanagedType)

Especifica un LPArray para calcular las referencias a código no administrado. La longitud de un LPArray se determina en tiempo de ejecución por el tamaño de la matriz convertida.

System_CAPS_pubmethodSystem_CAPS_staticDefineSafeArray(UnmanagedType)

Especifica un SafeArray para calcular las referencias a código no administrado.

System_CAPS_pubmethodSystem_CAPS_staticDefineUnmanagedMarshal(UnmanagedType)

Especifica un tipo determinado que es necesario calcular las referencias a código no administrado.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

El ejemplo de código muestra la solución para este tipo obsoleto.

Cálculo de referencias es el proceso de empaquetado y desempaquetado de parámetros para que se realice llamadas a procedimiento remoto. Durante este proceso, un campo puede someterse a una conversión de formato cuando el formato del tipo administrado es distinto del formato del tipo no administrado correspondiente. Por ejemplo, puede calcular las referencias de un String tipo como un tipo BSTR no administrado. Algunas conversiones de formato se controlan automáticamente en tiempo de ejecución. Para invalidar el comportamiento predeterminado, debe utilizar el UnmanagedMarshal clase para definir la conversión de formato.

En el ejemplo de código siguiente se muestra el código de reemplazo para el atributo obsolete UnmanagedMarshal tipo. En el ejemplo se emite un ensamblado de único módulo denominado EmitMarshalAs.dll, que contiene un tipo denominado Sample. El tipo tiene un método denominado Test, con un parámetro de tipo String. El ejemplo de código se aplica el MarshalAsAttribute con UnmanagedType.BStr para el parámetro.

Puede usar el Ildasm.exe (IL Disassembler) para examinar el ensamblado emitido y observar que se ha marcado el parámetro marshal(bstr).

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

.NET Framework
Disponible desde 1.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: