AppDomainSetup.DynamicBase Propriedade

Definição

Obtém ou define o diretório base no qual se encontra o diretório para arquivos gerados dinamicamente.Gets or sets the base directory where the directory for dynamically generated files is located.

public:
 property System::String ^ DynamicBase { System::String ^ get(); void set(System::String ^ value); };
public string DynamicBase { get; set; }
member this.DynamicBase : string with get, set
Public Property DynamicBase As String

Valor da propriedade

String

O diretório em que o DynamicDirectory está localizado.The directory where the DynamicDirectory is located.


O valor retornado dessa propriedade é diferente do valor atribuído.The return value of this property is different from the value assigned.

Implementações

Exceções

Essa propriedade não pode ser definida porque o nome do aplicativo no domínio do aplicativo é null.This property cannot be set because the application name on the application domain is null.

Exemplos

O exemplo a seguir demonstra como usar a DynamicBase propriedade para definir o caminho que um domínio de aplicativo investiga ao carregar assemblies dinâmicos.The following example demonstrates how to use the DynamicBase property to set the path an application domain probes when loading dynamic assemblies.

O exemplo cria um AppDomainSetup objeto e define sua ApplicationName propriedade como "example" e sua DynamicBase propriedade como "C:\DynamicAssemblyDir".The example creates an AppDomainSetup object and sets its ApplicationName property to "Example" and its DynamicBase property to "C:\DynamicAssemblyDir". Em seguida, o exemplo exibe a DynamicBase propriedade para mostrar que o código hash do nome do aplicativo foi anexado como um subdiretório do caminho que foi originalmente atribuído.The example then displays the DynamicBase property, to show that the hash code of the application name has been appended as a subdirectory of the path that was originally assigned.

Observação

O diretório base neste exemplo deve estar fora do caminho de investigação para o aplicativo de exemplo.The base directory in this example is intended to be outside the probing path for the example application. Certifique-se de compilar o exemplo em um local diferente.Be sure to compile the example in a different location. Exclua o diretório base e todos os seus subdiretórios sempre que você executar o exemplo.Delete the base directory and all its subdirectories each time you run the example.

O exemplo cria um novo domínio de aplicativo usando o AppDomainSetup objeto.The example creates a new application domain using the AppDomainSetup object. Em seguida, o exemplo cria o diretório dinâmico, caso ele ainda não exista.The example then creates the dynamic directory if it does not already exist. Embora o exemplo use a propriedade do domínio do aplicativo AppDomain.DynamicDirectory para obter o nome do diretório dinâmico, ele poderia simplesmente criar o diretório com a concatenação do caminho original, o código hash do nome do aplicativo e o nome do aplicativo.Although the example uses the application domain's AppDomain.DynamicDirectory property to get the name of the dynamic directory, it could just as easily create the directory beforehand by concatenating the original path, the hash code of the application name, and the application name.

O exemplo tem um GenerateDynamicAssembly método que emite um assembly chamado DynamicHelloWorld.dll e o armazena no diretório dinâmico do novo domínio do aplicativo.The example has a GenerateDynamicAssembly method that emits an assembly named DynamicHelloWorld.dll and stores it in the new application domain's dynamic directory. O assembly dinâmico contém um tipo, HelloWorld , que tem um método estático ( Shared método em Visual Basic) chamado HelloFromAD .The dynamic assembly contains one type, HelloWorld, that has a static method (Shared method in Visual Basic) named HelloFromAD. Chamar esse método exibe o nome do domínio do aplicativo.Calling this method displays the name of the application domain.

A Example classe deriva de MarshalByRefObject , portanto, o exemplo pode criar uma instância da classe no novo domínio do aplicativo e chamar seu Test método.The Example class derives from MarshalByRefObject, so the example can create an instance of the class in the new application domain and call its Test method. O Test método carrega o assembly dinâmico por seu nome de exibição e chama o HelloFromAD método estático.The Test method loads the dynamic assembly by its display name and calls the static HelloFromAD method.

Você pode mostrar que o diretório dinâmico é pesquisado após os caminhos de investigação normais, escrevendo código para um assembly chamado DynamicHelloWorld.dll e compilando-o no mesmo diretório que este exemplo.You can show that the dynamic directory is searched after the normal probing paths by writing code for an assembly named DynamicHelloWorld.dll and compiling it in the same directory as this example. O assembly deve ter uma classe chamada HelloWorld com um método estático chamado HelloFromAD .The assembly must have a class named HelloWorld with a static method named HelloFromAD. Esse método não precisa ter a mesma funcionalidade que a do exemplo; Ele pode simplesmente exibir uma cadeia de caracteres para o console.This method does not have to have the same functionality as the one in the example; it can simply display a string to the console. O assembly também deve ter um AssemblyVersionAttribute atributo que defina sua versão como 1.0.0.0.The assembly must also have an AssemblyVersionAttribute attribute that sets its version to 1.0.0.0. Quando você executa o exemplo, o assembly que você compilou no diretório atual é encontrado antes que o diretório dinâmico seja pesquisado.When you run the example, the assembly you compiled in the current directory is found before the dynamic directory is searched.

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

Comentários

Use essa propriedade para definir o diretório base onde o diretório dinâmico do novo domínio de aplicativo será localizado.Use this property to set the base directory where the dynamic directory for the new application domain will be located. Quando o código no novo domínio do aplicativo carrega um assembly, a resolução do assembly parece primeiro nos caminhos de investigação normais.When code in the new application domain loads an assembly, assembly resolution looks first in the normal probing paths. Se ele não encontrar o assembly, ele procurará no diretório dinâmico, que é retornado pela AppDomain.DynamicDirectory propriedade.If it does not find the assembly, it looks in the dynamic directory, which is returned by the AppDomain.DynamicDirectory property. Os assemblies dinâmicos que serão carregados e executados pelo novo domínio de aplicativo poderão ser colocados lá.Dynamic assemblies that will be loaded and executed by the new application domain can be placed there.

Quando você atribui um caminho à DynamicBase propriedade, um subdiretório adicional é adicionado; o nome desse subdiretório é o código hash do valor atribuído à ApplicationName propriedade.When you assign a path to the DynamicBase property, an additional subdirectory is added; the name of this subdirectory is the hash code of the value assigned to the ApplicationName property. Portanto, o diretório base subsequentemente retornado por essa propriedade é sempre diferente do valor atribuído.Thus, the base directory subsequently returned by this property is always different from the value assigned.

Importante

A atribuição de um valor a essa propriedade não cria diretórios.Assigning a value to this property does not create any directories. Os diretórios devem ser criados ou verificados pelo código que os utiliza.The directories must be created or verified by the code that uses them.

O diretório dinâmico é um subdiretório de DynamicBase .The dynamic directory is a subdirectory of DynamicBase. Seu nome simples é o valor retornado pela ApplicationName Propriedade; portanto, seu formato é o nome do aplicativo de \ código hash do caminho original \ .Its simple name is the value returned by the ApplicationName property, so its format is original path\hash code\application name.

Aplica-se a