Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método AppDomain.CreateInstanceAndUnwrap (String, String, Object[])

 

Publicado: octubre de 2016

Crea una nueva instancia del tipo especificado. Los parámetros especifican el ensamblado en el que se definen el tipo, el nombre del tipo y una matriz de atributos de activación.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

Parámetros

assemblyName
Type: System.String

Nombre para mostrar del ensamblado. Vea Assembly.FullName.

typeName
Type: System.String

Nombre completo del tipo solicitado, incluido el espacio de nombres, pero no el ensamblado, tal y como lo devuelve la propiedad Type.FullName.

activationAttributes
Type: System.Object[]

Matriz de uno o más atributos que puede participar en la activación. Normalmente, una matriz que contiene un único objeto UrlAttribute que especifica la dirección URL necesaria para activar un objeto remoto.

Este parámetro está relacionado con los objetos activados en el cliente. Activación del cliente es una tecnología heredada que se conserva por compatibilidad con versiones anteriores, pero no se recomienda para nuevo desarrollo. Las aplicaciones distribuidas deberían usar Windows Communication Foundation.

Valor devuelto

Type: System.Object

Instancia del objeto especificado por typeName.

Exception Condition
ArgumentNullException

El valor de assemblyName o typeName es null.

MissingMethodException

No se encontró ningún constructor público coincidente.

TypeLoadException

No se encontró typename en assemblyName.

FileNotFoundException

No se encontró assemblyName.

MethodAccessException

El llamador no tiene permiso para llamar a este constructor.

NotSupportedException

El llamador no puede ofrecer atributos de activación para un objeto que no hereda de MarshalByRefObject.

AppDomainUnloadedException

La operación se intenta en un dominio de aplicación descargado.

BadImageFormatException

assemblyName no es un ensamblado válido.

-o-

Actualmente está cargada la versión 2.0 o posterior de common language runtime y assemblyName se compiló con una versión posterior.

FileLoadException

Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.

Se trata de un método útil que combina CreateInstance y ObjectHandle.Unwrap. Este método llama al constructor predeterminado de typeName.

Consulte AssemblyName para el formato de assemblyName. Consulte la Type.FullName propiedad de formato de typeName.

System_CAPS_noteNota

Si se realiza una llamada enlazada a un método M de un objeto del tipo T1 que devolvió CreateInstanceAndUnwrap, y que este método realiza una llamada enlazada a un método de un objeto del tipo T2 en un ensamblado C que no sea el ensamblado actual o el ensamblado que contiene T1, ensamblado C se carga en el dominio de aplicación actual. Esta carga se produce incluso si el tiempo de compilación la llamada a T1.M() se realizó en el cuerpo de un DynamicMethod, o en otro código generado dinámicamente. Si el dominio actual es el dominio predeterminado, el ensamblado C no se puede descargar hasta que finaliza el proceso. Si más adelante, el dominio actual intenta cargar el ensamblado C, podría producirse un error en la carga.


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
Disponible desde 1.1
Volver al principio
Mostrar: