Tento článek byl přeložený strojově. Pokud chcete zobrazit článek v angličtině, zaškrtněte políčko Angličtina. Anglickou verzi článku můžete také zobrazit v místním okně přesunutím ukazatele myši nad text.
Překlad
Angličtina

Metoda AppDomain.CreateInstanceAndUnwrap (String, String, Object[])

.NET Framework (current version)
 

Vytvoří novou instanci určeného typu. Parametry zadejte sestavení, kde je definován typ, název typu a pole atributy aktivace.

Obor názvů:   System
Sestavení:  mscorlib (v mscorlib.dll)

public object CreateInstanceAndUnwrap(
	string assemblyName,
	string typeName,
	object[] activationAttributes
)

Parametry

assemblyName
Type: System.String

Zobrazovaný název sestavení. Viz Assembly.FullName.

typeName
Type: System.String

Plně kvalifikovaný název požadovaného typu včetně oboru názvů ale nikoli sestavení, která vrací Type.FullName vlastnost.

activationAttributes
Type: System.Object[]

Pole jeden nebo více atributů, které mohou podílet na aktivaci. Obvykle, pole, které obsahuje jediný UrlAttribute objekt, který určuje adresu URL, která je vyžadována k aktivaci vzdáleného objektu.

Tento parametr je spojen s objekty aktivovanými klientem. Aktivace klienta je starší verze technologií, která je zachován z důvodu zpětné kompatibility však není doporučováno pro nový vývoj. Distribuované aplikace by měly používat místo Windows Communication Foundation.

Návratová hodnota

Type: System.Object

Instance objektu určeného parametrem typeName.

Exception Condition
ArgumentNullException

assemblyName nebo typeName je null.

MissingMethodException

Nebyl nalezen žádný odpovídající veřejný konstruktor.

TypeLoadException

typename nebyl nalezen v assemblyName.

FileNotFoundException

assemblyName nebyl nalezen.

MethodAccessException

Volající nemá oprávnění k volání tohoto konstruktoru.

NotSupportedException

Volající nemůže poskytnout atributy aktivace pro objekt, který nedědí z MarshalByRefObject.

AppDomainUnloadedException

Dojde k pokusu o operaci na uvolněné doméně aplikace.

BadImageFormatException

assemblyName není platné sestavení.

- nebo -

Aktuálně je zaveden verze 2.0 nebo novější common language runtime a assemblyName byl kompilován s novější verzí.

FileLoadException

Sestavení nebo modul byly zavedeny dvakrát se dvěma různými legitimacemi.

Toto je popisná metoda, která kombinuje CreateInstance a ObjectHandle.Unwrap. Tato metoda volá výchozí konstruktor pro typeName.

Viz AssemblyName pro formát assemblyName. Viz Type.FullName vlastnost pro formát typeName.

System_CAPS_notePoznámka

Je-li provést volání časné vazby na metodu M objektu typu T1 který vrátila CreateInstanceAndUnwrap, a že metoda provede volání časné vazby na metodu objektu typu T2 v sestavení C než aktuální sestavení nebo sestavení obsahující T1, sestavení C je načten do aktuální domény aplikace. Toto načtení dojde i v případě, že volání časné vazby T1.M() byl proveden v těle DynamicMethod, nebo v jiném dynamicky generovaném kódu. Pokud je aktuální doména výchozí doménou, sestavení C lze uvolit až po ukončení procesu. Pokud se aktuální doména se později pokusí načíst sestavení C, načtení může selhat.


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[] { });


   }

}

FileIOPermissionAccess

for the ability to access the location of the assembly. Associated enumeration: F:System.Security.Permissions.FileIOPermissionAccess.PathDiscovery

FileIOPermissionAccess

for the ability to read the file containing the assembly manifest. Associated enumeration: F:System.Security.Permissions.FileIOPermissionAccess.Read

WebPermission

for the ability to access the location of the assembly if the assembly is not local.

SecurityPermission

for the ability to call unmanaged code when creating an instance of a delegate. Associated enumeration: F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode

ReflectionPermission

for the ability to invoke operations on all type members. Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.MemberAccess

.NET Framework
K dispozici od 1.1
Zpět na začátek
Zobrazit: