tipo - uso de objetos en c#
¿Puedo cargar un ensamblado.NET en tiempo de ejecución e instanciar un tipo que solo conozca el nombre? (13)
A partir de Framework v4.5 puede usar Activator.CreateInstanceFrom () para crear fácilmente instancias de clases dentro de ensamblajes. El siguiente ejemplo muestra cómo usarlo y cómo llamar a un método para pasar parámetros y obtener un valor de retorno.
// Assuming moduleFileName contains full or valid relative path to assembly
var moduleInstance = Activator.CreateInstanceFrom(moduleFileName, "MyNamespace.MyClass");
MethodInfo mi = moduleInstance.Unwrap().GetType().GetMethod("MyMethod");
// Assuming the method returns a boolean and accepts a single string parameter
bool rc = Convert.ToBoolean(mi.Invoke(moduleInstance.Unwrap(), new object[] { "MyParamValue" } ));
¿Es posible instanciar un objeto en tiempo de ejecución si solo tengo el nombre de DLL y el nombre de clase, sin agregar una referencia al ensamblado en el proyecto? La clase implementa una interfaz, por lo que una vez que instalé la clase, la lanzaré a la interfaz.
Nombre de la Asamblea:
library.dll
Escribe un nombre:
Company.Project.Classname
EDITAR: No tengo la ruta absoluta de la DLL, por lo que Assembly.LoadFile no funcionará. La DLL puede estar en la raíz de la aplicación, system32 o incluso cargada en el GAC.
Considere las limitaciones de los diferentes métodos Load* . Desde los documentos de MSDN ...
LoadFile no carga archivos en el contexto LoadFrom y no resuelve dependencias utilizando la ruta de carga, como lo hace el método LoadFrom.
Puede encontrar más información sobre Load Contexts en LoadFrom docs.
Dependiendo de cuán intrínseco es este tipo de funcionalidad para su proyecto, es posible que desee considerar algo como MEF que se encargará de cargar y vincular los componentes por usted.
Encontré esta pregunta y algunas respuestas muy útiles, sin embargo, tuve problemas de ruta, por lo que esta respuesta cubriría la carga de la biblioteca al encontrar la ruta del directorio bin.
Primera solución:
string assemblyName = "library.dll";
string assemblyPath = HttpContext.Current.Server.MapPath("~/bin/" + assemblyName);
Assembly assembly = Assembly.LoadFrom(assemblyPath);
Type T = assembly.GetType("Company.Project.Classname");
Company.Project.Classname instance = (Company.Project.Classname) Activator.CreateInstance(T);
Segunda solución
string assemblyName = "library.dll";
string assemblyPath = HttpContext.Current.Server.MapPath("~/bin/" + assemblyName);
Assembly assembly = Assembly.LoadFile(assemblyPath);
(Company.Project.Classname) instance = (Company.Project.Classname) assembly.CreateInstance("Company.Project.Classname");
Puede usar el mismo principio para las interfaces (crearía una clase, pero la conversión a la interfaz), como por ejemplo:
(Company.Project.Interfacename) instance = (Company.Project.Interfacename) assembly.CreateInstance("Company.Project.Classname");
Este ejemplo es para aplicaciones web pero similar podría usarse para aplicaciones de escritorio, solo la ruta se resuelve de forma diferente, por ejemplo
Path.GetDirectoryName(Application.ExecutablePath)
Es fácil.
Ejemplo de MSDN:
public static void Main()
{
// Use the file name to load the assembly into the current
// application domain.
Assembly a = Assembly.Load("example");
// Get the type to use.
Type myType = a.GetType("Example");
// Get the method to call.
MethodInfo myMethod = myType.GetMethod("MethodA");
// Create an instance.
object obj = Activator.CreateInstance(myType);
// Execute the method.
myMethod.Invoke(obj, null);
}
Aquí hay un enlace de referencia
Puede cargar un ensamblaje utilizando los métodos * Assembly.Load **. Usando Activator.CreateInstance puede crear nuevas instancias del tipo que desee. Tenga en cuenta que debe usar el nombre de tipo completo de la clase que desea cargar (por ejemplo, Namespace.SubNamespace.ClassName ). Usando el método InvokeMember de la clase Type puede invocar métodos sobre el tipo.
Además, tenga en cuenta que una vez cargado, un ensamblaje no se puede descargar hasta que todo el AppDomain esté descargado también (esto es básicamente una pérdida de memoria).
Puedes hacer esto de esta manera:
using System.Reflection;
Assembly MyDALL = Assembly.Load("DALL"); //DALL name of your assembly
Type MyLoadClass = MyDALL.GetType("DALL.LoadClass"); // name of your class
object obj = Activator.CreateInstance(MyLoadClass);
Sí, lo es, deseará usar el método Load estático en la clase Assembly, y luego llamar y llamar al método CreateInstance en la instancia de Assembly devuelta desde la llamada a Load.
Además, puede llamar a uno de los otros métodos estáticos que comienzan con "Cargar" en la clase de ensamblaje, según sus necesidades.
Sí. Debe usar Assembly.LoadFrom para cargar el ensamblaje en la memoria, luego puede usar Activator.CreateInstance para crear una instancia de su tipo preferido. Tendrá que buscar primero el tipo usando reflexión. Aquí hay un ejemplo simple:
Assembly assembly = Assembly.LoadFrom("MyNice.dll");
Type type = assembly.GetType("MyType");
object instanceOfMyType = Activator.CreateInstance(type);
Actualizar
Cuando tenga el nombre de archivo de ensamblado y el nombre de tipo, puede usar Activator.CreateInstance para solicitar que la resolución de tipo .NET lo resuelva en un tipo. Podría envolverlo con un try / catch para que, si falla, pueda realizar una búsqueda en directorios donde pueda almacenar específicamente ensamblajes adicionales que de otro modo podrían no buscarse. Esto usaría el método anterior en ese punto.
Sí. No tengo ningún ejemplo que haya hecho personalmente disponible en este momento. Lo publicaré más tarde cuando encuentre alguno. Básicamente, utilizará la reflexión para cargar el conjunto y luego extraer los tipos que necesite.
Mientras tanto, este enlace debería ayudarte a comenzar:
Usar reflexión para cargar ensamblajes sin referencia en tiempo de ejecución
Activator.CreateInstance debería funcionar.
IFace object = (IFace)Activator.CreateInstance( "AssemblyName",
"TypeName" )
.Unwrap();
Nota: El nombre del tipo debe ser del tipo totalmente calificado.
Ejemplo:
var aray = (IList)Activator.CreateInstance("mscorlib","System.Collections.ArrayList").Unwrap();
aray.Add(10);
foreach (object obj in aray)
{
Console.WriteLine(obj);
}
((ISomeInterface)Activator.CreateInstance(Assembly.LoadFile("somePath").GetTypes()[0])).SomeInterfaceMethod();
Assembly assembly = Assembly.LoadFrom("MyAssembly.dll");
Type type = assembly.GetType("MyType");
dynamic instanceOfMyType = Activator.CreateInstance(type);
De esta forma, puede usar funciones no con get methodinfo, y luego invocarlo. Hará como este instanceOfMyType.MethodName (); Pero no puede usar Intellisense porque los tipos dinámicos se escriben en tiempo de ejecución, no en tiempo de compilación.