Export (0) Print
Expand All

AppDomain.SetDynamicBase Method

NOTE: This API is now obsolete. The non-obsolete alternative is DynamicBase.

Establishes the specified directory path as the base directory for subdirectories where dynamically generated files are stored and accessed.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

[ObsoleteAttribute("AppDomain.SetDynamicBase has been deprecated. Please investigate the use of AppDomainSetup.DynamicBase instead. http://go.microsoft.com/fwlink/?linkid=14202")]
[SecurityPermissionAttribute(SecurityAction.LinkDemand, ControlAppDomain = true)]
public void SetDynamicBase(
	string path


Type: System.String

The fully qualified path that is the base directory for subdirectories where dynamic assemblies are stored.


The operation is attempted on an unloaded application domain.

This method sets the DynamicBase property of the internal AppDomainSetup associated with this instance.

This method is now obsolete, and should not be used for new development.

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

      // Generate a dynamic assembly and store it in the dynamic  
      // directory.

      // 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( 
         Assembly.GetExecutingAssembly().FullName, "Example");

   public void Test()
      Assembly dynAssem = Assembly.Load(
         "DynamicHelloWorld, Version=, 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 
      AssemblyName asmName = new AssemblyName("DynamicHelloWorld");
      asmName.Version = new Version("");

      AssemblyBuilder ab = 
            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) }));

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

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

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 1.1, 1.0
Obsolete (compiler warning) in 3.5
Obsolete (compiler warning) in 3.5 SP1
Obsolete (compiler warning) in 3.0
Obsolete (compiler warning) in 3.0 SP1
Obsolete (compiler warning) in 3.0 SP2
Obsolete (compiler warning) in 2.0
Obsolete (compiler warning) in 2.0 SP1
Obsolete (compiler warning) in 2.0 SP2

Community Additions

© 2015 Microsoft