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

AppDomain.DynamicDirectory (Propiedad)

 

Obtiene el directorio que la resolución de ensamblado usa para buscar ensamblados creados de forma dinámica.

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

public string DynamicDirectory { get; }

Valor de propiedad

Type: System.String

Directorio que la resolución de ensamblado usa para buscar ensamblados creados de forma dinámica.

Exception Condition
AppDomainUnloadedException

Se intentó realizar la operación en un dominio de aplicación descargado.

Para establecer el directorio dinámico, asigne una ruta de acceso del directorio base para el AppDomainSetup.DynamicBase propiedad de la AppDomainSetup objeto que se utilizará para crear el nuevo dominio de aplicación.Se modifica la ruta de acceso del directorio base se asigna a la propiedad mediante la adición de un subdirectorio cuyo nombre simple es el código hash de la cadena que asigne a la AppDomainSetup.ApplicationName propiedad, por lo que es el formato del directorio base ruta de acceso original\código hash.El directorio dinámico es un subdirectorio del directorio base.Su nombre simple es el valor de la AppDomainSetup.ApplicationName propiedad, por lo que su formato es ruta de acceso original\código hash\nombre de la aplicación.

En el ejemplo siguiente se crea un dominio de aplicación con un directorio para los ensamblados dinámicos, emite un ensamblado dinámico y almacena en el directorio dinámico y, a continuación, carga el ensamblado en el nuevo dominio de aplicación y lo utiliza.

El ejemplo se crea un AppDomainSetup objeto y establece su ApplicationName propiedad en "Ejemplo" y su DynamicBase propiedad "C:\DynamicAssemblyDir".En el ejemplo, a continuación, muestra la DynamicBase propiedad, para mostrar que se ha anexado el código hash del nombre de la aplicación como un subdirectorio de la ruta de acceso que se asignó originalmente.

System_CAPS_noteNota

El directorio base en este ejemplo se pretende ser fuera de la ruta de acceso de búsqueda para la aplicación de ejemplo.Asegúrese de compilar el ejemplo en una ubicación diferente.Elimine el directorio base y todos sus subdirectorios cada vez que ejecute el ejemplo.

En el ejemplo se crea un nuevo dominio de aplicación, usando la AppDomainSetup objeto.El ejemplo se utiliza la DynamicDirectory propiedad para recuperar el nombre del directorio, por lo que puede crear el directorio.(El ejemplo podría fácilmente crear el directorio previamente mediante la concatenación de la ruta de acceso original, el código hash del nombre de la aplicación y el nombre de la aplicación.)

El ejemplo tiene un GenerateDynamicAssembly método que emite un ensamblado denominado DynamicHelloWorld.dll y lo almacena en el directorio de aplicación del nuevo dominio dinámico.El ensamblado dinámico contiene un tipo HelloWorld, que tiene un método estático (Shared método en Visual Basic) denominado HelloFromAD.Llamar a este método, muestra el nombre del dominio de aplicación.

El Example clase se deriva de MarshalByRefObject, por lo que en el ejemplo se puede crear una instancia de la clase en el nuevo dominio de aplicación y llamar su Test método.El Test método carga el ensamblado dinámico mediante su nombre para mostrar y llama a estático HelloFromAD método.

Puede mostrar que se busca el directorio dinámico después de las rutas de búsqueda normales al escribir código para un ensamblado denominado DynamicHelloWorld.dll y compilar en el mismo directorio que este ejemplo.El ensamblado debe tener una clase denominada HelloWorld con un método estático denominado HelloFromAD.Este método no debe tener la misma funcionalidad que la que se muestra en el ejemplo; simplemente puede mostrar una cadena en la consola.El ensamblado debe tener también un AssemblyVersionAttribute atributo que establece la versión 1.0.0.0.Al ejecutar el ejemplo, se encuentra el ensamblado compilado en el directorio actual antes de que se busca en el directorio dinámico.

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

public class Example : MarshalByRefObject
{
   static void Main()
   {
      // Prepare to create a new application domain.
      AppDomainSetup setup = new AppDomainSetup();

      // Set the application name before setting the dynamic base.
      setup.ApplicationName = "Example";

      // Set the location of the base directory where assembly resolution 
      // probes for dynamic assemblies. Note that the hash code of the 
      // application name is concatenated to the base directory name you 
      // supply. 
      setup.DynamicBase = "C:\\DynamicAssemblyDir";
      Console.WriteLine("DynamicBase is set to '{0}'.", setup.DynamicBase);

      AppDomain ad = AppDomain.CreateDomain("MyDomain", null, setup);

      // The dynamic directory name is the dynamic base concatenated with
      // the application name: <DynamicBase>\<hash code>\<ApplicationName>
      string dynamicDir = ad.DynamicDirectory;
      Console.WriteLine("Dynamic directory is '{0}'.", dynamicDir);

      // The AssemblyBuilder won't create this directory automatically.
      if (!System.IO.Directory.Exists(dynamicDir))
      {
         Console.WriteLine("Creating the dynamic directory.");
         System.IO.Directory.CreateDirectory(dynamicDir);
      }

      // Generate a dynamic assembly and store it in the dynamic 
      // directory.
      GenerateDynamicAssembly(dynamicDir);

      // Create an instance of the Example class in the application domain,
      // and call its Test method to load the dynamic assembly and use it.
      Example ex = (Example) ad.CreateInstanceAndUnwrap(
         typeof(Example).Assembly.FullName, "Example");
      ex.Test();
   }

   public void Test()
   {
      Assembly dynAssem = Assembly.Load(
         "DynamicHelloWorld, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");

      Type myType = dynAssem.GetType("HelloWorld");
      myType.InvokeMember("HelloFromAD", BindingFlags.Public | 
         BindingFlags.Static | BindingFlags.InvokeMethod, 
         Type.DefaultBinder, null, null);
   }


   private static void GenerateDynamicAssembly(string location)
   {
      // Define the dynamic assembly and the module. There is only one
      // module in this assembly. Note that the call to DefineDynamicAssembly 
      // specifies the location where the assembly will be saved. The 
      // assembly version is 1.0.0.0.
      //
      AssemblyName asmName = new AssemblyName("DynamicHelloWorld");
      asmName.Version = new Version("1.0.0.0");

      AssemblyBuilder ab = 
         AppDomain.CurrentDomain.DefineDynamicAssembly( 
            asmName, AssemblyBuilderAccess.Save, location);

      String moduleName = asmName.Name + ".exe";
      ModuleBuilder mb = ab.DefineDynamicModule(asmName.Name, moduleName);

      // Define the "HelloWorld" type, with one static method.
      TypeBuilder tb = mb.DefineType("HelloWorld", TypeAttributes.Public);
      MethodBuilder hello = tb.DefineMethod("HelloFromAD", 
         MethodAttributes.Public | MethodAttributes.Static, null, null);

      // The method displays a message that contains the name of the application
      // domain where the method is executed.
      ILGenerator il = hello.GetILGenerator();
      il.Emit(OpCodes.Ldstr, "Hello from '{0}'!");
      il.Emit(OpCodes.Call, typeof(AppDomain).GetProperty("CurrentDomain").GetGetMethod());
      il.Emit(OpCodes.Call, typeof(AppDomain).GetProperty("FriendlyName").GetGetMethod());
      il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", 
                             new Type[] { typeof(String), typeof(String) }));
      il.Emit(OpCodes.Ret);

      // Complete the HelloWorld type and save the assembly. The assembly
      // is placed in the location specified by DefineDynamicAssembly.
      Type myType = tb.CreateType();
      ab.Save(moduleName);
   }
}

/* This example produces output similar to the following:

DynamicBase is set to 'C:\DynamicAssemblyDir\5e4a7545'.
Dynamic directory is 'C:\DynamicAssemblyDir\5e4a7545\Example'.
Creating the dynamic directory.
Hello from 'MyDomain'!
 */

FileIOPermission

for access to the path information.Associated enumeration: FileIOPermissionAccess.PathDiscovery.

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: