AppDomain.DynamicDirectory Propiedad

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: System.Runtime.Extensions.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

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

public:
 property System::String ^ DynamicDirectory { System::String ^ get(); };

public string? DynamicDirectory { get; }

public string DynamicDirectory { get; }

member this.DynamicDirectory : string

Public ReadOnly Property DynamicDirectory As String

Valor de propiedad

String

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

Implementaciones

DynamicDirectory

Excepciones

AppDomainUnloadedException

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

Ejemplos

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

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

Nota

El directorio base de este ejemplo está pensado para estar fuera de la ruta de acceso de sondeo de la aplicación de ejemplo. Asegúrese de compilar el ejemplo en otra ubicación. 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 mediante el AppDomainSetup objeto . En el ejemplo se usa la DynamicDirectory propiedad para recuperar el nombre del directorio, por lo que puede crear el directorio. (El ejemplo podría crear de antemano el directorio de antemano 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 dinámico del nuevo dominio de aplicación. El ensamblado dinámico contiene un tipo, HelloWorld, que tiene un método estático (Shared método en Visual Basic) denominado HelloFromAD. Al llamar a este método, se muestra el nombre del dominio de aplicación.

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

Puede mostrar que el directorio dinámico se busca después de las rutas de acceso de sondeo normales escribiendo código para un ensamblado denominado DynamicHelloWorld.dll y compilarlo en el mismo directorio que en este ejemplo. El ensamblado debe tener una clase denominada HelloWorld con un método estático denominado HelloFromAD. Este método no tiene que tener la misma funcionalidad que la del ejemplo; simplemente puede mostrar una cadena en la consola. El ensamblado también debe tener un AssemblyVersionAttribute atributo que establezca su versión en 1.0.0.0. Al ejecutar el ejemplo, se busca el ensamblado compilado en el directorio actual antes de buscar en el directorio dinámico.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

public ref class Example : MarshalByRefObject
{
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, nullptr, nullptr);
   }
};


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 = gcnew AssemblyName("DynamicHelloWorld");
   asmName->Version = gcnew 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, nullptr, nullptr);

   // 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, AppDomain::typeid->GetProperty("CurrentDomain")->GetGetMethod());
   il->Emit(OpCodes::Call, AppDomain::typeid->GetProperty("FriendlyName")->GetGetMethod());
   il->Emit(OpCodes::Call, Console::typeid->GetMethod("WriteLine", 
                            gcnew array<Type^> { String::typeid, String::typeid }));
   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);
};

void main()
{
   // Prepare to create a new application domain.
   AppDomainSetup^ setup = gcnew 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", nullptr, 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( 
         Example::typeid->Assembly->FullName, "Example");
   ex->Test();
}

/* 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'!
 */

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'!
 */

open System
open System.Reflection
open System.Reflection.Emit

type Example() =
    inherit MarshalByRefObject()
    member _.Test() =
        let dynAssem = 
            Assembly.Load "DynamicHelloWorld, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"

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

    static member GenerateDynamicAssembly(location: string) =
        // 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.
        let asmName = AssemblyName "DynamicHelloWorld"
        asmName.Version <- Version "1.0.0.0"

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

        let moduleName = asmName.Name + ".exe"
        let mb = ab.DefineDynamicModule(asmName.Name, moduleName)

        // Define the "HelloWorld" type, with one static method.
        let tb = mb.DefineType("HelloWorld", TypeAttributes.Public)
        let 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.
        let 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", [| 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.
        let myType = tb.CreateType()
        ab.Save moduleName

// Prepare to create a new application domain.
let setup = 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"
printfn $"DynamicBase is set to '{setup.DynamicBase}'."

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

// The dynamic directory name is the dynamic base concatenated with
// the application name: <DynamicBase>\<hash code>\<ApplicationName>
let dynamicDir = ad.DynamicDirectory
printfn $"Dynamic directory is '{dynamicDir}'."

// The AssemblyBuilder won't create this directory automatically.
if not (System.IO.Directory.Exists dynamicDir) then
    printfn "Creating the dynamic directory."
    System.IO.Directory.CreateDirectory dynamicDir
    |> ignore

// Generate a dynamic assembly and store it in the dynamic
// directory.
Example.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.
let ex = ad.CreateInstanceAndUnwrap(typeof<Example>.Assembly.FullName, "Example") :?> Example
ex.Test()

(* 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'!
 *)

Imports System.Reflection
Imports System.Reflection.Emit

Public Class Example 
   Inherits MarshalByRefObject
   
   Shared Sub Main(args() As String)

      ' Prepare to create a new application domain.
      Dim setup As 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)

      Dim ad As AppDomain = AppDomain.CreateDomain("MyDomain", Nothing, setup)
      
      ' The dynamic directory name is the dynamic base concatenated with
      ' the application name: <DynamicBase>\<hash code>\<ApplicationName>
      Dim dynamicDir As String = ad.DynamicDirectory 
      Console.WriteLine("Dynamic directory is '{0}'.", dynamicDir)

      ' The AssemblyBuilder won't create this directory automatically.
      If Not System.IO.Directory.Exists(dynamicDir) Then 
         Console.WriteLine("Creating the dynamic directory.")
         System.IO.Directory.CreateDirectory(dynamicDir)
      End If

      ' 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.  
      Dim ex As Example = CType( _
         ad.CreateInstanceAndUnwrap( _
            GetType(Example).Assembly.FullName, "Example"), Example)
      ex.Test()
   End Sub

   Public Sub Test() 

      Dim dynAssem As [Assembly] = Assembly.Load(
         "DynamicHelloWorld, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")

      Dim myType As Type = dynAssem.GetType("HelloWorld")
      myType.InvokeMember("HelloFromAD", BindingFlags.Public Or _
         BindingFlags.Static Or BindingFlags.InvokeMethod, _
         Type.DefaultBinder, Nothing, Nothing) 'New Object() {})
   End Sub


   Private Shared Sub GenerateDynamicAssembly(ByVal location As String)
      
      ' 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.
      '
      Dim asmName As New AssemblyName("DynamicHelloWorld")
      asmName.Version = New Version("1.0.0.0")

      Dim ab As AssemblyBuilder = _
         AppDomain.CurrentDomain.DefineDynamicAssembly( _
            asmName, AssemblyBuilderAccess.Save, location)

      Dim moduleName As String = asmName.Name & ".dll"
      Dim mb As ModuleBuilder = ab.DefineDynamicModule(asmName.Name, moduleName)
      
      ' Define the "HelloWorld" type, with one static method.
      Dim tb As TypeBuilder = mb.DefineType("HelloWorld", TypeAttributes.Public)
      Dim hello As MethodBuilder = tb.DefineMethod("HelloFromAD", _
         MethodAttributes.Public Or MethodAttributes.Static, Nothing, Nothing)

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

      ' Complete the HelloWorld type and save the assembly. The assembly
      ' is placed in the location specified by DefineDynamicAssembly.
      Dim myType As Type = tb.CreateType()
      ab.Save(moduleName)
   End Sub
End Class 

' 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'!

Comentarios

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

Se aplica a

Compartir vía