AppDomain.SetDynamicBase Method

Establishes the specified directory path as the location where dynamically generated files are stored and accessed.

[Visual Basic]
Public Sub SetDynamicBase( _
   ByVal path As String _
)
[C#]
public void SetDynamicBase(
 string path
);
[C++]
public: void SetDynamicBase(
 String* path
);
[JScript]
public function SetDynamicBase(
   path : String
);

Parameters

path

The fully-qualified path to where dynamic assemblies are stored.

Exceptions

Remarks

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

Example

[Visual Basic] 
Imports System
Imports System.Reflection
Imports System.Reflection.Emit



Class ADDynamicBase
   
   ' SetDynamicBase.exe
   Overloads Shared Sub Main(args() As String)
      ' Create a new AppDomain.
      Dim setup As New AppDomainSetup()
      ' Need to set the application name before setting the dynamic base.
      setup.ApplicationName = "MyApplication"
      Dim domain As AppDomain = AppDomain.CreateDomain("MyDomain", Nothing, setup)
      
      ' Tell the domain to search for assemblies in DynamicAssemblyDir.
      domain.SetDynamicBase("C:\DynamicAssemblyDir")
      
      ' Note that the actual dynamic directory has the form
      ' <DynamicBase>\<number>\<ApplicationName>, rather than
      ' simply <DynamicBase>.
      Dim dynamicDir As [String] = domain.DynamicDirectory
      ' The AssemblyBuilder won't create this directory automatically.
      If Not System.IO.Directory.Exists(dynamicDir) Then
         System.IO.Directory.CreateDirectory(dynamicDir)
      End If
      
      ' Define the dynamic assembly.
      Dim asmName As New AssemblyName()
      asmName.Name = "DynamicHelloWorld"
      Dim asm As AssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Save, dynamicDir)
      
      ' Define a dynamic module in the assembly.
      Dim [mod] As ModuleBuilder
      [mod] = asm.DefineDynamicModule("DynamicHelloWorld", "DynamicHelloWorld.dll")
      
      ' Define the "HelloWorld" type in the module.
      Dim typ As TypeBuilder = [mod].DefineType("HelloWorld", TypeAttributes.Public)
      
      ' Define the "SayHello" method.
      Dim meth As MethodBuilder = typ.DefineMethod("SayHello", MethodAttributes.Public, Nothing, Nothing)
      Dim il As ILGenerator = meth.GetILGenerator()
      il.EmitWriteLine("Hello World!")
      il.Emit(OpCodes.Ret)
      
      ' Complete the HelloWorld type.
      typ.CreateType()
      
      ' Save the assembly to the dynamic assembly directory.
      asm.Save("DynamicHelloWorld.dll")
      
      ' Launch MyExecutable.exe, which will load DynamicHelloWorld.dll.
      domain.ExecuteAssembly("MyExecutable.exe")
   End Sub 'Main
End Class 'ADDynamicBase

[C#] 
using System;
using System.Reflection;
using System.Reflection.Emit;

namespace AppDomainSnippets
{
    class ADDynamicBase
    {
        // SetDynamicBase.exe
        static void Main(string[] args)
        {
            // Create a new AppDomain.
            AppDomainSetup setup = new AppDomainSetup();
            // Need to set the application name before setting the dynamic base.
            setup.ApplicationName = "MyApplication";
            AppDomain domain = AppDomain.CreateDomain("MyDomain", null, setup);

            // Tell the domain to search for assemblies in DynamicAssemblyDir.
            domain.SetDynamicBase("C:\\DynamicAssemblyDir");
            
            // Note that the actual dynamic directory has the form
            // <DynamicBase>\<number>\<ApplicationName>, rather than
            // simply <DynamicBase>.
            String dynamicDir = domain.DynamicDirectory;
            // The AssemblyBuilder won't create this directory automatically.
            if(!System.IO.Directory.Exists(dynamicDir))
            {
                System.IO.Directory.CreateDirectory(dynamicDir);
            }

            // Define the dynamic assembly.
            AssemblyName asmName = new AssemblyName();
            asmName.Name = "DynamicHelloWorld";
            AssemblyBuilder asm = AppDomain.CurrentDomain.DefineDynamicAssembly
                (asmName, AssemblyBuilderAccess.Save, dynamicDir);

            // Define a dynamic module in the assembly.
            ModuleBuilder mod;
            mod = asm.DefineDynamicModule
                ("DynamicHelloWorld", "DynamicHelloWorld.dll");

            // Define the "HelloWorld" type in the module.
            TypeBuilder typ = mod.DefineType
                ("HelloWorld", TypeAttributes.Public);

            // Define the "SayHello" method.
            MethodBuilder meth = typ.DefineMethod
                ("SayHello", MethodAttributes.Public, null, null);
            ILGenerator il = meth.GetILGenerator();
            il.EmitWriteLine("Hello World!");
            il.Emit(OpCodes.Ret);

            // Complete the HelloWorld type.
            typ.CreateType();
            
            // Save the assembly to the dynamic assembly directory.
            asm.Save("DynamicHelloWorld.dll");

            // Launch MyExecutable.exe, which will load DynamicHelloWorld.dll.
            domain.ExecuteAssembly("MyExecutable.exe");
        }
    }
}

[C++] 
#using <mscorlib.dll>

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

// SetDynamicBase.exe
int main() {
    String* args[] = Environment::GetCommandLineArgs();
    // Create a new AppDomain.
    AppDomainSetup* setup = new AppDomainSetup();
    // Need to set the application name before setting the dynamic base.
    setup->ApplicationName = S"MyApplication";
    AppDomain*  domain = AppDomain::CreateDomain(S"MyDomain", 0, setup);

    // Tell the domain to search for assemblies in DynamicAssemblyDir.
    domain->SetDynamicBase(S"C:\\DynamicAssemblyDir");

    // Note that the actual dynamic directory has the form
    // <DynamicBase>\<number>\<ApplicationName>, rather than
    // simply <DynamicBase>.
    String*  dynamicDir = domain->DynamicDirectory;
    // The AssemblyBuilder won't create this directory automatically.
    if (!System::IO::Directory::Exists(dynamicDir)) {
        System::IO::Directory::CreateDirectory(dynamicDir);
    }

    // Define the dynamic assembly.
    AssemblyName* asmName = new AssemblyName();
    asmName->Name = S"DynamicHelloWorld";
    AssemblyBuilder*  asmb = AppDomain::CurrentDomain->DefineDynamicAssembly
        (asmName, AssemblyBuilderAccess::Save, dynamicDir);

    // Define a dynamic module in the assembly.
    ModuleBuilder* mod;
    mod = asmb->DefineDynamicModule
        (S"DynamicHelloWorld", S"DynamicHelloWorld.dll");

    // Define the S"HelloWorld" type in the module.
    TypeBuilder*  typ = mod->DefineType
        (S"HelloWorld", TypeAttributes::Public);

    // Define the S"SayHello" method.
    MethodBuilder*  meth = typ->DefineMethod
        (S"SayHello", MethodAttributes::Public, 0, 0);
    ILGenerator*  il = meth->GetILGenerator();
    il->EmitWriteLine(S"Hello World!");
    il->Emit(OpCodes::Ret);

    // Complete the HelloWorld type.
    typ->CreateType();

    // Save the assembly to the dynamic assembly directory.
    asmb->Save(S"DynamicHelloWorld.dll");

    // Launch MyExecutable.exe, which will load DynamicHelloWorld.dll.
    domain->ExecuteAssembly(S"MyExecutable.exe");
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

.NET Framework Security: 

• SecurityPermission for using this method. Associated enumeration: SecurityAction.LinkDemand.
• ReflectionPermission when invoked late-bound through mechanisms such as Type.InvokeMember. Associated enumeration: ReflectionPermissionFlag.MemberAccess.
• FileIOPermission for access to read from a file or directory, and for access to the information in the path itself. Associated enumerations: FileIOPermissionAccess.Read, FileIOPermissionAccess.PathDiscovery.

See Also

AppDomain Class | AppDomain Members | System Namespace | DynamicBase