Freigeben über


AppDomainSetup.LoaderOptimization-Eigenschaft

Gibt die Optimierungsrichtlinie zum Laden ausführbarer Dateien an.

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

Syntax

'Declaration
Public Property LoaderOptimization As LoaderOptimization
'Usage
Dim instance As AppDomainSetup
Dim value As LoaderOptimization

value = instance.LoaderOptimization

instance.LoaderOptimization = value
public LoaderOptimization LoaderOptimization { get; set; }
public:
property LoaderOptimization LoaderOptimization {
    LoaderOptimization get ();
    void set (LoaderOptimization value);
}
/** @property */
public LoaderOptimization get_LoaderOptimization ()

/** @property */
public void set_LoaderOptimization (LoaderOptimization value)
public function get LoaderOptimization () : LoaderOptimization

public function set LoaderOptimization (value : LoaderOptimization)

Eigenschaftenwert

Eine LoaderOptimization-Enumerationskonstante, die mit dem LoaderOptimizationAttribute verwendet wird.

Beispiel

Imports System
Imports System.IO
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Runtime.Remoting



Class ADDyno
   
   
   
   Public Shared Function CreateADynamicAssembly(ByRef myNewDomain As AppDomain, executableNameNoExe As String) As Type
      
      Dim executableName As String = executableNameNoExe + ".exe"
      
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = executableNameNoExe
      myAsmName.CodeBase = Environment.CurrentDirectory
      
      Dim myAsmBuilder As AssemblyBuilder = myNewDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
      Console.WriteLine("-- Dynamic Assembly instantiated.")
      
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule(executableNameNoExe, executableName)
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType(executableNameNoExe, TypeAttributes.Public, GetType(MarshalByRefObject))
      
      Dim myFCMethod As MethodBuilder = myTypeBuilder.DefineMethod("CountLocalFiles", MethodAttributes.Public Or MethodAttributes.Static, Nothing, New Type() {})
      
      Dim currentDirGetMI As MethodInfo = GetType(Environment).GetProperty("CurrentDirectory").GetGetMethod()
      Dim writeLine0objMI As MethodInfo = GetType(Console).GetMethod("WriteLine", New Type() {GetType(String)})
      Dim writeLine2objMI As MethodInfo = GetType(Console).GetMethod("WriteLine", New Type() {GetType(String), GetType(Object), GetType(Object)})
      Dim getFilesMI As MethodInfo = GetType(Directory).GetMethod("GetFiles", New Type() {GetType(String)})
      
      myFCMethod.InitLocals = True
      
      Dim myFCIL As ILGenerator = myFCMethod.GetILGenerator()
      
      Console.WriteLine("-- Generating MSIL method body...")
      Dim v0 As LocalBuilder = myFCIL.DeclareLocal(GetType(String))
      Dim v1 As LocalBuilder = myFCIL.DeclareLocal(GetType(Integer))
      Dim v2 As LocalBuilder = myFCIL.DeclareLocal(GetType(String))
      Dim v3 As LocalBuilder = myFCIL.DeclareLocal(GetType(String()))
      
      Dim evalForEachLabel As Label = myFCIL.DefineLabel()
      Dim topOfForEachLabel As Label = myFCIL.DefineLabel()
      
      ' Build the method body.
      myFCIL.EmitCall(OpCodes.Call, currentDirGetMI, Nothing)
      myFCIL.Emit(OpCodes.Stloc_S, v0)
      myFCIL.Emit(OpCodes.Ldc_I4_0)
      myFCIL.Emit(OpCodes.Stloc_S, v1)
      myFCIL.Emit(OpCodes.Ldstr, "---")
      myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, Nothing)
      myFCIL.Emit(OpCodes.Ldloc_S, v0)
      myFCIL.EmitCall(OpCodes.Call, getFilesMI, Nothing)
      myFCIL.Emit(OpCodes.Stloc_S, v3)
      
      myFCIL.Emit(OpCodes.Br_S, evalForEachLabel)
      
      ' foreach loop starts here.
      myFCIL.MarkLabel(topOfForEachLabel)
      
      ' Load array of strings and index, store value at index for output.
      myFCIL.Emit(OpCodes.Ldloc_S, v3)
      myFCIL.Emit(OpCodes.Ldloc_S, v1)
      myFCIL.Emit(OpCodes.Ldelem_Ref)
      myFCIL.Emit(OpCodes.Stloc_S, v2)
      
      myFCIL.Emit(OpCodes.Ldloc_S, v2)
      myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, Nothing)
      
      ' Increment counter by one.
      myFCIL.Emit(OpCodes.Ldloc_S, v1)
      myFCIL.Emit(OpCodes.Ldc_I4_1)
      myFCIL.Emit(OpCodes.Add)
      myFCIL.Emit(OpCodes.Stloc_S, v1)
      
      ' Determine if end of file list array has been reached.
      myFCIL.MarkLabel(evalForEachLabel)
      myFCIL.Emit(OpCodes.Ldloc_S, v1)
      myFCIL.Emit(OpCodes.Ldloc_S, v3)
      myFCIL.Emit(OpCodes.Ldlen)
      myFCIL.Emit(OpCodes.Conv_I4)
      myFCIL.Emit(OpCodes.Blt_S, topOfForEachLabel)
      'foreach loop end here.
      myFCIL.Emit(OpCodes.Ldstr, "---")
      myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, Nothing)
      myFCIL.Emit(OpCodes.Ldstr, "There are {0} files in {1}.")
      myFCIL.Emit(OpCodes.Ldloc_S, v1)
      myFCIL.Emit(OpCodes.Box, GetType(Integer))
      myFCIL.Emit(OpCodes.Ldloc_S, v0)
      myFCIL.EmitCall(OpCodes.Call, writeLine2objMI, Nothing)
      
      myFCIL.Emit(OpCodes.Ret)
      
      Dim myType As Type = myTypeBuilder.CreateType()
      
      myAsmBuilder.SetEntryPoint(myFCMethod)
      myAsmBuilder.Save(executableName)
      Console.WriteLine("-- Method generated, type completed, and assembly saved to disk.")
      
      Return myType
   End Function 'CreateADynamicAssembly
    
   
   Public Shared Sub Main()
      
      Dim executableName As String = Nothing
      Dim domainDir As String
      
      Console.Write("Enter a name for the file counting assembly: ")
      Dim executableNameNoExe As String = Console.ReadLine()
      executableName = executableNameNoExe + ".exe"
      Console.WriteLine("---")
      
      domainDir = Environment.CurrentDirectory
      
      Dim curDomain As AppDomain = Thread.GetDomain()
      
      
      ' Create a new AppDomain, with the current directory as the base.
      Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory)
      Dim mySetupInfo As New AppDomainSetup()
      mySetupInfo.ApplicationBase = domainDir
      mySetupInfo.ApplicationName = executableNameNoExe
      mySetupInfo.LoaderOptimization = LoaderOptimization.SingleDomain
      
      Dim myDomain As AppDomain = AppDomain.CreateDomain(executableNameNoExe, Nothing, mySetupInfo)
      
      Console.WriteLine("Creating a new AppDomain '{0}'...", executableNameNoExe)
      
      Console.WriteLine("-- Base Directory = '{0}'", myDomain.BaseDirectory)
      Console.WriteLine("-- Shadow Copy? = '{0}'", myDomain.ShadowCopyFiles)
      
      Console.WriteLine("---")
      Dim myFCType As Type = CreateADynamicAssembly(curDomain, executableNameNoExe)
      
      Console.WriteLine("Loading '{0}' from '{1}'...", executableName, myDomain.BaseDirectory.ToString())
      
      
      Dim bFlags As BindingFlags = BindingFlags.Public Or BindingFlags.CreateInstance Or BindingFlags.Instance
      
      Dim myObjInstance As [Object] = myDomain.CreateInstanceAndUnwrap(executableNameNoExe, executableNameNoExe, False, bFlags, Nothing, Nothing, Nothing, Nothing, Nothing)
      
      Console.WriteLine("Executing method 'CountLocalFiles' in {0}...", myObjInstance.ToString())
      
      myFCType.InvokeMember("CountLocalFiles", BindingFlags.InvokeMethod, Nothing, myObjInstance, New Object() {})
   End Sub 'Main
End Class 'ADDyno 


using System;
using System.IO;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.Remoting;

class ADDyno

{

   public static Type CreateADynamicAssembly(ref AppDomain myNewDomain,
                         string executableNameNoExe)
   {

    string executableName = executableNameNoExe + ".exe";

    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = executableNameNoExe;
    myAsmName.CodeBase = Environment.CurrentDirectory;

    AssemblyBuilder myAsmBuilder = myNewDomain.DefineDynamicAssembly(myAsmName,
                        AssemblyBuilderAccess.RunAndSave);
    Console.WriteLine("-- Dynamic Assembly instantiated.");

    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(executableNameNoExe,
                                      executableName);

    TypeBuilder myTypeBuilder = myModBuilder.DefineType(executableNameNoExe,
                        TypeAttributes.Public,
                        typeof(MarshalByRefObject));

    MethodBuilder myFCMethod = myTypeBuilder.DefineMethod("CountLocalFiles",
                        MethodAttributes.Public |
                        MethodAttributes.Static,
                        null,
                        new Type[] {  });

    MethodInfo currentDirGetMI = typeof(Environment).GetProperty("CurrentDirectory").GetGetMethod();
    MethodInfo writeLine0objMI = typeof(Console).GetMethod("WriteLine",
                     new Type[] { typeof(string) });
    MethodInfo writeLine2objMI = typeof(Console).GetMethod("WriteLine",
                     new Type[] { typeof(string), typeof(object), typeof(object) });
    MethodInfo getFilesMI = typeof(Directory).GetMethod("GetFiles", 
                new Type[] { typeof(string) });

    myFCMethod.InitLocals = true;

    ILGenerator myFCIL = myFCMethod.GetILGenerator();

    Console.WriteLine("-- Generating MSIL method body...");
    LocalBuilder v0 = myFCIL.DeclareLocal(typeof(string));
    LocalBuilder v1 = myFCIL.DeclareLocal(typeof(int));
    LocalBuilder v2 = myFCIL.DeclareLocal(typeof(string));
    LocalBuilder v3 = myFCIL.DeclareLocal(typeof(string[]));

    Label evalForEachLabel = myFCIL.DefineLabel();
    Label topOfForEachLabel = myFCIL.DefineLabel();

    // Build the method body.

    myFCIL.EmitCall(OpCodes.Call, currentDirGetMI, null);
    myFCIL.Emit(OpCodes.Stloc_S, v0);
    myFCIL.Emit(OpCodes.Ldc_I4_0);
    myFCIL.Emit(OpCodes.Stloc_S, v1);
    myFCIL.Emit(OpCodes.Ldstr, "---");
    myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);
    myFCIL.Emit(OpCodes.Ldloc_S, v0);
    myFCIL.EmitCall(OpCodes.Call, getFilesMI, null);
    myFCIL.Emit(OpCodes.Stloc_S, v3);

    myFCIL.Emit(OpCodes.Br_S, evalForEachLabel);

    // foreach loop starts here.
    myFCIL.MarkLabel(topOfForEachLabel);
    
        // Load array of strings and index, store value at index for output.
    myFCIL.Emit(OpCodes.Ldloc_S, v3);
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Ldelem_Ref);
    myFCIL.Emit(OpCodes.Stloc_S, v2);

    myFCIL.Emit(OpCodes.Ldloc_S, v2);
    myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);

    // Increment counter by one.
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Ldc_I4_1);
    myFCIL.Emit(OpCodes.Add);
    myFCIL.Emit(OpCodes.Stloc_S, v1);

    // Determine if end of file list array has been reached.
    myFCIL.MarkLabel(evalForEachLabel);
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Ldloc_S, v3);
    myFCIL.Emit(OpCodes.Ldlen);
    myFCIL.Emit(OpCodes.Conv_I4);
    myFCIL.Emit(OpCodes.Blt_S, topOfForEachLabel);
    //foreach loop end here.

    myFCIL.Emit(OpCodes.Ldstr, "---");
    myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);
    myFCIL.Emit(OpCodes.Ldstr, "There are {0} files in {1}.");
    myFCIL.Emit(OpCodes.Ldloc_S, v1);
    myFCIL.Emit(OpCodes.Box, typeof(int));
    myFCIL.Emit(OpCodes.Ldloc_S, v0);
    myFCIL.EmitCall(OpCodes.Call, writeLine2objMI, null);

    myFCIL.Emit(OpCodes.Ret);

    Type myType = myTypeBuilder.CreateType();

    myAsmBuilder.SetEntryPoint(myFCMethod);
    myAsmBuilder.Save(executableName);      
    Console.WriteLine("-- Method generated, type completed, and assembly saved to disk."); 

    return myType;

   }

   public static void Main() 
   {

    string domainDir, executableName = null;
    
    Console.Write("Enter a name for the file counting assembly: ");
    string executableNameNoExe = Console.ReadLine();
    executableName = executableNameNoExe + ".exe";
    Console.WriteLine("---");

    domainDir = Environment.CurrentDirectory;

    AppDomain curDomain = Thread.GetDomain();   


    // Create a new AppDomain, with the current directory as the base.

    Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory);
    AppDomainSetup mySetupInfo = new AppDomainSetup();
    mySetupInfo.ApplicationBase = domainDir;
    mySetupInfo.ApplicationName = executableNameNoExe;
    mySetupInfo.LoaderOptimization = LoaderOptimization.SingleDomain;

    AppDomain myDomain = AppDomain.CreateDomain(executableNameNoExe,
                    null, mySetupInfo);

    Console.WriteLine("Creating a new AppDomain '{0}'...",
                    executableNameNoExe);

    Console.WriteLine("-- Base Directory = '{0}'", myDomain.BaseDirectory); 
    Console.WriteLine("-- Shadow Copy? = '{0}'", myDomain.ShadowCopyFiles); 

    Console.WriteLine("---");
    Type myFCType = CreateADynamicAssembly(ref curDomain, 
                     executableNameNoExe);

    Console.WriteLine("Loading '{0}' from '{1}'...", executableName,
              myDomain.BaseDirectory.ToString());


    BindingFlags bFlags = (BindingFlags.Public | BindingFlags.CreateInstance |
                   BindingFlags.Instance);

    Object myObjInstance = myDomain.CreateInstanceAndUnwrap(executableNameNoExe,
                executableNameNoExe, false, bFlags, 
                null, null, null, null, null);

    Console.WriteLine("Executing method 'CountLocalFiles' in {0}...",
               myObjInstance.ToString());

    myFCType.InvokeMember("CountLocalFiles", BindingFlags.InvokeMethod, null,
                myObjInstance, new object[] { });
            
        
   }

}
using namespace System;
using namespace System::IO;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Runtime::Remoting;

ref class ADDyno
{
public:
   static Type^ CreateADynamicAssembly( interior_ptr<AppDomain^> myNewDomain, String^ executableNameNoExe )
   {
      String^ executableName = String::Concat( executableNameNoExe, ".exe" );
      AssemblyName^ myAsmName = gcnew AssemblyName;
      myAsmName->Name = executableNameNoExe;
      myAsmName->CodeBase = Environment::CurrentDirectory;
      AssemblyBuilder^ myAsmBuilder = ( *myNewDomain)->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::RunAndSave );
      Console::WriteLine( "-- Dynamic Assembly instantiated." );
      ModuleBuilder^ myModBuilder = myAsmBuilder->DefineDynamicModule( executableNameNoExe, executableName );
      TypeBuilder^ myTypeBuilder = myModBuilder->DefineType( executableNameNoExe, TypeAttributes::Public, MarshalByRefObject::typeid );
      array<Type^>^temp0 = nullptr;
      MethodBuilder^ myFCMethod = myTypeBuilder->DefineMethod( "CountLocalFiles", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), nullptr, temp0 );
      MethodInfo^ currentDirGetMI = Environment::typeid->GetProperty( "CurrentDirectory" )->GetGetMethod();
      array<Type^>^temp1 = {String::typeid};
      MethodInfo^ writeLine0objMI = Console::typeid->GetMethod( "WriteLine", temp1 );
      array<Type^>^temp2 = {String::typeid,Object::typeid,Object::typeid};
      MethodInfo^ writeLine2objMI = Console::typeid->GetMethod( "WriteLine", temp2 );
      array<Type^>^temp3 = {String::typeid};
      MethodInfo^ getFilesMI = Directory::typeid->GetMethod( "GetFiles", temp3 );
      myFCMethod->InitLocals = true;
      ILGenerator^ myFCIL = myFCMethod->GetILGenerator();
      Console::WriteLine( "-- Generating MSIL method body..." );
      LocalBuilder^ v0 = myFCIL->DeclareLocal( String::typeid );
      LocalBuilder^ v1 = myFCIL->DeclareLocal( int::typeid );
      LocalBuilder^ v2 = myFCIL->DeclareLocal( String::typeid );
      LocalBuilder^ v3 = myFCIL->DeclareLocal( array<String^>::typeid );
      Label evalForEachLabel = myFCIL->DefineLabel();
      Label topOfForEachLabel = myFCIL->DefineLabel();

      // Build the method body.
      myFCIL->EmitCall( OpCodes::Call, currentDirGetMI, nullptr );
      myFCIL->Emit( OpCodes::Stloc_S, v0 );
      myFCIL->Emit( OpCodes::Ldc_I4_0 );
      myFCIL->Emit( OpCodes::Stloc_S, v1 );
      myFCIL->Emit( OpCodes::Ldstr, "---" );
      myFCIL->EmitCall( OpCodes::Call, writeLine0objMI, nullptr );
      myFCIL->Emit( OpCodes::Ldloc_S, v0 );
      myFCIL->EmitCall( OpCodes::Call, getFilesMI, nullptr );
      myFCIL->Emit( OpCodes::Stloc_S, v3 );
      myFCIL->Emit( OpCodes::Br_S, evalForEachLabel );

      // foreach loop starts here.
      myFCIL->MarkLabel( topOfForEachLabel );

      // Load array of strings and index, store value at index for output.
      myFCIL->Emit( OpCodes::Ldloc_S, v3 );
      myFCIL->Emit( OpCodes::Ldloc_S, v1 );
      myFCIL->Emit( OpCodes::Ldelem_Ref );
      myFCIL->Emit( OpCodes::Stloc_S, v2 );
      myFCIL->Emit( OpCodes::Ldloc_S, v2 );
      myFCIL->EmitCall( OpCodes::Call, writeLine0objMI, nullptr );

      // Increment counter by one.
      myFCIL->Emit( OpCodes::Ldloc_S, v1 );
      myFCIL->Emit( OpCodes::Ldc_I4_1 );
      myFCIL->Emit( OpCodes::Add );
      myFCIL->Emit( OpCodes::Stloc_S, v1 );

      // Determine if end of file list array has been reached.
      myFCIL->MarkLabel( evalForEachLabel );
      myFCIL->Emit( OpCodes::Ldloc_S, v1 );
      myFCIL->Emit( OpCodes::Ldloc_S, v3 );
      myFCIL->Emit( OpCodes::Ldlen );
      myFCIL->Emit( OpCodes::Conv_I4 );
      myFCIL->Emit( OpCodes::Blt_S, topOfForEachLabel );

      //foreach loop end here.
      myFCIL->Emit( OpCodes::Ldstr, "---" );
      myFCIL->EmitCall( OpCodes::Call, writeLine0objMI, nullptr );
      myFCIL->Emit( OpCodes::Ldstr, "There are {0} files in {1}." );
      myFCIL->Emit( OpCodes::Ldloc_S, v1 );
      myFCIL->Emit( OpCodes::Box, int::typeid );
      myFCIL->Emit( OpCodes::Ldloc_S, v0 );
      myFCIL->EmitCall( OpCodes::Call, writeLine2objMI, nullptr );
      myFCIL->Emit( OpCodes::Ret );
      Type^ myType = myTypeBuilder->CreateType();
      myAsmBuilder->SetEntryPoint( myFCMethod );
      myAsmBuilder->Save( executableName );
      Console::WriteLine( "-- Method generated, type completed, and assembly saved to disk." );
      return myType;
   }
};

int main()
{
   String^ domainDir;
   String^ executableName = nullptr;
   Console::Write( "Enter a name for the file counting assembly: " );
   String^ executableNameNoExe = Console::ReadLine();
   executableName = String::Concat( executableNameNoExe, ".exe" );
   Console::WriteLine( "---" );
   domainDir = Environment::CurrentDirectory;
   AppDomain^ curDomain = Thread::GetDomain();

   // Create a new AppDomain, with the current directory as the base.
   Console::WriteLine( "Current Directory: {0}", Environment::CurrentDirectory );
   AppDomainSetup^ mySetupInfo = gcnew AppDomainSetup;
   mySetupInfo->ApplicationBase = domainDir;
   mySetupInfo->ApplicationName = executableNameNoExe;
   mySetupInfo->LoaderOptimization = LoaderOptimization::SingleDomain;
   AppDomain^ myDomain = AppDomain::CreateDomain( executableNameNoExe, nullptr, mySetupInfo );
   Console::WriteLine( "Creating a new AppDomain '{0}'...", executableNameNoExe );
   Console::WriteLine( "-- Base Directory = '{0}'", myDomain->BaseDirectory );
   Console::WriteLine( "-- Shadow Copy? = '{0}'", myDomain->ShadowCopyFiles );
   Console::WriteLine( "---" );
   Type^ myFCType = ADDyno::CreateADynamicAssembly(  &curDomain, executableNameNoExe );
   Console::WriteLine( "Loading '{0}' from '{1}'...", executableName, myDomain->BaseDirectory );
   BindingFlags bFlags = static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::CreateInstance | BindingFlags::Instance);
   Object^ myObjInstance = myDomain->CreateInstanceAndUnwrap( executableNameNoExe, executableNameNoExe, false, bFlags, nullptr, nullptr, nullptr, nullptr, nullptr );
   Console::WriteLine( "Executing method 'CountLocalFiles' in {0}...", myObjInstance );
   array<Object^>^temp4 = nullptr;
   myFCType->InvokeMember( "CountLocalFiles", BindingFlags::InvokeMethod, nullptr, myObjInstance, temp4 );
}
import System.*;
import System.IO.*;
import System.Threading.*;
import System.Reflection.*;
import System.Reflection.Emit.*;
import System.Runtime.Remoting.*;

class ADDyno
{
    public static Type CreateADynamicAssembly(AppDomain myNewDomain, 
        String executableNameNoExe) 
    {
        String executableName = executableNameNoExe + ".exe";
        AssemblyName myAsmName =  new AssemblyName();
        myAsmName.set_Name(executableNameNoExe);
        myAsmName.set_CodeBase(Environment.get_CurrentDirectory());

        AssemblyBuilder myAsmBuilder = 
            myNewDomain.DefineDynamicAssembly(myAsmName, 
            AssemblyBuilderAccess.RunAndSave);
        Console.WriteLine("-- Dynamic Assembly instantiated.");

        ModuleBuilder myModBuilder = 
            myAsmBuilder.DefineDynamicModule(executableNameNoExe, 
            executableName);

        TypeBuilder myTypeBuilder = myModBuilder.DefineType(executableNameNoExe,
            TypeAttributes.Public, MarshalByRefObject.class.ToType());

        MethodBuilder myFCMethod = myTypeBuilder.DefineMethod("CountLocalFiles", 
            MethodAttributes.Public | MethodAttributes.Static, null, 
            new Type[]{});

        MethodInfo currentDirGetMI = Environment.class.ToType().
            GetProperty("CurrentDirectory").GetGetMethod();
        MethodInfo writeLine0ObjMI = Console.class.ToType().
            GetMethod("WriteLine", new Type[]{String.class.ToType()});
        MethodInfo writeLine2ObjMI = Console.class.ToType().
            GetMethod("WriteLine", new Type[]{String.class.ToType(), 
            Object.class.ToType(), Object.class.ToType()});
        MethodInfo getFilesMI = Directory.class.ToType().GetMethod("GetFiles", 
            new Type[]{String.class.ToType()});

        myFCMethod.set_InitLocals(true);
        ILGenerator myFCIL = myFCMethod.GetILGenerator();

        Console.WriteLine("-- Generating MSIL method body...");
        LocalBuilder v0 = myFCIL.DeclareLocal(String.class.ToType());
        LocalBuilder v1 = myFCIL.DeclareLocal(int.class.ToType());
        LocalBuilder v2 = myFCIL.DeclareLocal(String.class.ToType());
        LocalBuilder v3 = myFCIL.DeclareLocal(String[].class.ToType());

        Label evalForEachLabel = myFCIL.DefineLabel();
        Label topOfForEachLabel = myFCIL.DefineLabel();

        // Build the method body.
        myFCIL.EmitCall(OpCodes.Call, currentDirGetMI, null);
        myFCIL.Emit(OpCodes.Stloc_S, v0);
        myFCIL.Emit(OpCodes.Ldc_I4_0);
        myFCIL.Emit(OpCodes.Stloc_S, v1);
        myFCIL.Emit(OpCodes.Ldstr, "---");
        myFCIL.EmitCall(OpCodes.Call, writeLine0ObjMI, null);
        myFCIL.Emit(OpCodes.Ldloc_S, v0);
        myFCIL.EmitCall(OpCodes.Call, getFilesMI, null);
        myFCIL.Emit(OpCodes.Stloc_S, v3);

        myFCIL.Emit(OpCodes.Br_S, evalForEachLabel);

        // foreach loop starts here.
        myFCIL.MarkLabel(topOfForEachLabel);

        // Load array of strings and index, store value at index for output.
        myFCIL.Emit(OpCodes.Ldloc_S, v3);
        myFCIL.Emit(OpCodes.Ldloc_S, v1);
        myFCIL.Emit(OpCodes.Ldelem_Ref);
        myFCIL.Emit(OpCodes.Stloc_S, v2);

        myFCIL.Emit(OpCodes.Ldloc_S, v2);
        myFCIL.EmitCall(OpCodes.Call, writeLine0ObjMI, null);

        // Increment counter by one.
        myFCIL.Emit(OpCodes.Ldloc_S, v1);
        myFCIL.Emit(OpCodes.Ldc_I4_1);
        myFCIL.Emit(OpCodes.Add);
        myFCIL.Emit(OpCodes.Stloc_S, v1);

        // Determine if end of file list array has been reached.
        myFCIL.MarkLabel(evalForEachLabel);
        myFCIL.Emit(OpCodes.Ldloc_S, v1);
        myFCIL.Emit(OpCodes.Ldloc_S, v3);
        myFCIL.Emit(OpCodes.Ldlen);
        myFCIL.Emit(OpCodes.Conv_I4);
        myFCIL.Emit(OpCodes.Blt_S, topOfForEachLabel);
        //foreach loop end here.

        myFCIL.Emit(OpCodes.Ldstr, "---");
        myFCIL.EmitCall(OpCodes.Call, writeLine0ObjMI, null);
        myFCIL.Emit(OpCodes.Ldstr, "There are {0} files in {1}.");
        myFCIL.Emit(OpCodes.Ldloc_S, v1);
        myFCIL.Emit(OpCodes.Box, int.class.ToType());
        myFCIL.Emit(OpCodes.Ldloc_S, v0);
        myFCIL.EmitCall(OpCodes.Call, writeLine2ObjMI, null);

        myFCIL.Emit(OpCodes.Ret);

        Type myType = myTypeBuilder.CreateType();

        myAsmBuilder.SetEntryPoint(myFCMethod);
        myAsmBuilder.Save(executableName);
        Console.WriteLine("-- Method generated, type completed, "
            + "and assembly saved to disk.");

        return myType;
    } //CreateADynamicAssembly

    public static void main(String[] args)
    {
        String executableName = null;
        String domainDir;

        Console.Write("Enter a name for the file counting assembly: ");
        String executableNameNoExe = Console.ReadLine();
        executableName = executableNameNoExe + ".exe";
        Console.WriteLine("---");

        domainDir = Environment.get_CurrentDirectory();
        AppDomain curDomain = System.Threading.Thread.GetDomain();

        // Create a new AppDomain, with the current directory as the base.
        Console.WriteLine("Current Directory: {0}", 
            Environment.get_CurrentDirectory());
        AppDomainSetup mySetupInfo =  new AppDomainSetup();
        mySetupInfo.set_ApplicationBase(domainDir);
        mySetupInfo.set_ApplicationName(executableNameNoExe);
        mySetupInfo.set_LoaderOptimization(LoaderOptimization.SingleDomain);

        AppDomain myDomain = AppDomain.CreateDomain(executableNameNoExe, null, 
            mySetupInfo);

        Console.WriteLine("Creating a new AppDomain '{0}'...", 
            executableNameNoExe);
        Console.WriteLine("-- Base Directory = '{0}'", myDomain.get_BaseDirectory());
        Console.WriteLine("-- Shadow Copy? = '{0}'", 
            (System.Boolean)myDomain.get_ShadowCopyFiles());
        Console.WriteLine("---");

        Type myFCType = CreateADynamicAssembly(curDomain, executableNameNoExe);
        Console.WriteLine("Loading '{0}' from '{1}'...", executableName, 
            myDomain.get_BaseDirectory().ToString());

        BindingFlags bFlags = BindingFlags.Public | BindingFlags.CreateInstance 
            | BindingFlags.Instance;

        Object myObjInstance = 
            myDomain.CreateInstanceAndUnwrap(executableNameNoExe, 
            executableNameNoExe, false, bFlags, null, null, null, null, null);

        Console.WriteLine("Executing method 'CountLocalFiles' in {0}...", 
            myObjInstance.ToString());

        myFCType.InvokeMember("CountLocalFiles", BindingFlags.InvokeMethod, 
            null, myObjInstance, new Object[]{});
   } //main
} //ADDyno 

Plattformen

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

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

AppDomainSetup-Klasse
AppDomainSetup-Member
System-Namespace