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

Método AppDomain.Load (Byte[], Byte[])

 

Publicado: octubre de 2016

Carga el Assembly con una imagen basada en el formato COFF (Common Object File Format) que contiene un Assembly emitido. También se cargan los bytes sin formato que representan los símbolos del Assembly.

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

public Assembly Load(
	byte[] rawAssembly,
	byte[] rawSymbolStore
)

Parámetros

rawAssembly
Type: System.Byte[]

Matriz de tipo byte que es una imagen basada en COFF que contiene un ensamblado emitido.

rawSymbolStore
Type: System.Byte[]

Matriz de tipo byte que contiene los bytes sin formato que representan los símbolos del ensamblado.

Valor devuelto

Type: System.Reflection.Assembly

Ensamblado cargado.

Exception Condition
ArgumentNullException

El valor de rawAssembly es null.

BadImageFormatException

rawAssembly no es un ensamblado válido.

-o-

Actualmente está cargada la versión 2.0 o posterior de common language runtime y rawAssembly se compiló con una versión posterior.

AppDomainUnloadedException

La operación se intenta en un dominio de aplicación descargado.

FileLoadException

Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.

A partir de la .NET Framework 4, el nivel de confianza de un ensamblado que se carga mediante el uso de este método es el mismo que el nivel de confianza del dominio de aplicación.

Este método se debe utilizar sólo para cargar un ensamblado en el dominio de aplicación actual. Este método se proporciona por comodidad para los llamadores de interoperabilidad que no pueden llamar estático Assembly.Load método. Para cargar ensamblados en otros dominios de aplicación, utilice un método como CreateInstanceAndUnwrap.

Para obtener información que es común a todas las sobrecargas de este método, consulte el Load(AssemblyName) sobrecarga del método.

En el ejemplo siguiente se muestra el uso de la carga de un ensamblado sin procesar.

Para que ejecutar este ejemplo de código, debe proporcionar el nombre completo del ensamblado. Para obtener información acerca de cómo obtener el nombre de ensamblado completo, vea Nombres de ensamblado.

using System;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;

class Test {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolver);

      InstantiateMyType(currentDomain);   // OK!
   }

   static void InstantiateMyType(AppDomain domain) {
      try {
	 // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   // Loads the content of a file to a byte array. 
   static byte[] loadFile(string filename) {
      FileStream fs = new FileStream(filename, FileMode.Open);
      byte[] buffer = new byte[(int) fs.Length];
      fs.Read(buffer, 0, buffer.Length);
      fs.Close();

      return buffer;
   }   

   static Assembly MyResolver(object sender, ResolveEventArgs args) {
      AppDomain domain = (AppDomain) sender;

      // Once the files are generated, this call is
      // actually no longer necessary.
      EmitAssembly(domain);

      byte[] rawAssembly = loadFile("temp.dll");
      byte[] rawSymbolStore = loadFile("temp.pdb");
      Assembly assembly = domain.Load(rawAssembly, rawSymbolStore);

      return assembly;
   }

   // Creates a dynamic assembly with symbol information
   // and saves them to temp.dll and temp.pdb
   static void EmitAssembly(AppDomain domain) {
      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyModule", "temp.dll", true);
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyType", TypeAttributes.Public);

      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();
      ilGenerator.EmitWriteLine("MyType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      assemblyBuilder.Save("temp.dll");
   }
}

WebPermission

for reading a URI that does not begin with "file://".

FileIOPermission

for access to read from a file or directory, and for access to the information in the path itself. Associated enumerations: F:System.Security.Permissions.FileIOPermissionAccess.Read, F:System.Security.Permissions.FileIOPermissionAccess.PathDiscovery.

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: