다음을 통해 공유


AppDomain.DynamicDirectory 속성

정의

어셈블리 확인자에서 동적으로 만든 어셈블리를 조사하는 데 사용하는 디렉터리를 가져옵니다.

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

속성 값

String

어셈블리 확인자에서 동적으로 만든 어셈블리를 조사하는 데 사용하는 디렉터리입니다.

구현

예외

언로드된 애플리케이션 도메인에서 작업이 시도됩니다.

예제

다음 예제에서는 동적 어셈블리에 대 한 디렉터리를 사용 하 여 애플리케이션 도메인을 만듭니다, 그리고 동적 어셈블리를 내보내 및 동적 디렉터리에 저장 한 다음 새 애플리케이션 도메인에 어셈블리를 로드 및 사용 합니다.

이 예제에서는 개체를 AppDomainSetup 만들고 해당 ApplicationName 속성을 "Example"로 설정하고 해당 DynamicBase 속성을 "C:\DynamicAssemblyDir"로 설정합니다. 다음 예제의 DynamicBase 애플리케이션 이름의 해시 코드를 원래 할당 된 경로의 하위 디렉터리로 추가 되었는지는 표시할 속성입니다.

참고

이 예제의 기본 디렉터리에 예제 애플리케이션에 대 한 검색 경로 외부에 있을 것입니다. 다른 위치에서 예제를 컴파일해야 합니다. 예제를 실행할 때마다 기본 디렉터리와 모든 하위 디렉터리를 삭제합니다.

예제에서는 새 애플리케이션 도메인을 만들고 사용 하 여는 AppDomainSetup 개체입니다. 이 예제에서는 디렉터리를 만들 수 있도록 속성을 사용하여 DynamicDirectory 디렉터리의 이름을 검색합니다. (이 예제에서는 간단 하 게 만들 수 디렉터리 미리 원래 경로, 애플리케이션 이름과 애플리케이션 이름, 해시 코드를 연결 하 여.)

이 예제에는 GenerateDynamicAssembly 이라는 어셈블리를 생성 하는 메서드 DynamicHelloWorld.dll 새 애플리케이션 도메인의 동적 디렉터리에 저장 합니다. 동적 어셈블리에는 이름이 정적 메서드(SharedVisual Basic)인 하나의 형식HelloWorld이 포함됩니다HelloFromAD. 이 메서드를 호출 애플리케이션 도메인의 이름을 표시 합니다.

Example 클래스에서 파생 되며 MarshalByRefObject예제에서는 새 애플리케이션 도메인 및 호출에서 클래스의 인스턴스를 만들 수 있으므로 해당 Test 메서드. 메서드는 Test 동적 어셈블리를 표시 이름으로 로드하고 정적 HelloFromAD 메서드를 호출합니다.

이 예제와 동일한 디렉터리에서 명명 DynamicHelloWorld.dll 된 어셈블리에 대한 코드를 작성하고 컴파일하여 동적 디렉터리가 일반 검색 경로 이후 검색됨을 표시할 수 있습니다. 어셈블리에는 명명HelloFromAD된 정적 메서드가 있는 HelloWorld 클래스가 있어야 합니다. 이 메서드는 예제의 기능과 동일한 기능을 가질 필요가 없습니다. 단순히 콘솔에 문자열을 표시할 수 있습니다. 어셈블리에는 해당 버전을 1.0.0.0으로 설정하는 특성도 AssemblyVersionAttribute 있어야 합니다. 예제를 실행하면 동적 디렉터리를 검색하기 전에 현재 디렉터리에서 컴파일한 어셈블리를 찾습니다.

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

설명

동적 디렉터리를 설정 하려면 기본 디렉터리 경로를 할당 합니다 AppDomainSetup.DynamicBase 속성의는 AppDomainSetup 새 애플리케이션 도메인을 만드는 데 사용할 개체입니다. 속성에 할당하는 기본 디렉터리 경로는 간단한 이름이 속성에 할당 AppDomainSetup.ApplicationName 하는 문자열의 해시 코드인 하위 디렉터리를 추가하여 수정되므로 기본 디렉터리의 형식은 원래 경로\해시 코드 입니다. 동적 디렉터리가 이 기본 디렉터리의 하위 디렉터리입니다. 단순 이름은 속성의 AppDomainSetup.ApplicationName 값이므로 해당 형식은 원래 경로\해시 코드\애플리케이션 이름 입니다.

적용 대상