.net - instalar - netbeans dark look and feel themes download

¿Cómo cargar complementos en.NET?

Question

Me gustaría proporcionar alguna forma de crear complementos dinámicamente cargables en mi software. La forma típica de hacerlo es usar la función LoadLibrary WinAPI para cargar un dll y llamar a GetProcAddress para obtener un puntero a una función dentro de ese dll.

Mi pregunta es ¿cómo cargo dinámicamente un complemento en la aplicación C # /. Net?

Answer 1

Carga dinámica de complementos

Para obtener información sobre cómo cargar dinámicamente conjuntos .NET, vea esta pregunta (y mi respuesta ). Aquí hay un código para cargar creando un AppDomain y cargando un ensamblado en él.

var domain = AppDomain.CreateDomain("NewDomainName");
var pathToDll = @"C:/myDll.dll";
var t = typeof(TypeIWantToLoad);
var runnable = domain.CreateInstanceFromAndUnwrap(pathToDll, t.FullName)
as IRunnable;
if (runnable == null) throw new Exception("broke");
runnable.Run();

Descarga de complementos

Un requisito típico de un marco de plugins es descargar los complementos. Para descargar ensamblajes cargados dinámicamente (por ejemplo, complementos y complementos), debe descargar el AppDomain que lo contiene. Para obtener más información, consulte este artículo en MSDN al descargar AppDomains .

Usando WCF

Hay una pregunta y respuesta de desbordamiento de pila que describe cómo usar Windows Communication Framework (WCF) para crear un marco de plugins.

Marcos de plug-in existentes

Sé de dos marcos de plugins:

• Mono.Add-ins : como se menciona en esta respuesta a otra pregunta .
• Managed Add-in Framework (MAF) - Este es el espacio de nombres System.AddIn como lo mencionó Matt en su respuesta .

Algunas personas hablan sobre el Marco de Extensibilidad Administrado (MEF) como un complemento o marco complementario, que no es. Para obtener más información, vea esta pregunta de StackOverflow.com y esta pregunta de StackOverflow.com .

Answer 2

A partir de .NET 3.5, existe una forma formalizada de crear y cargar complementos desde una aplicación .NET. Todo está en el espacio de nombres System.AddIn . Para obtener más información, puede consultar este artículo en MSDN: Complementos y Extensibilidad

Answer 3

Básicamente puedes hacerlo de dos maneras.

El primero es importar kernel32.dll y usar LoadLibrary y GetProcAddress como lo usaste antes:

[DllImport("kernel32.dll")]
internal static extern IntPtr LoadLibrary(String dllname);
[DllImport("kernel32.dll")]
internal static extern IntPtr GetProcAddress(IntPtr hModule, String procname);

El segundo es hacerlo en .NET-way: mediante el uso de la reflexión. Verifique el espacio de nombres System.Reflection y los siguientes métodos:

• Assembly.LoadFile
• Assembly.GetType
• Assembly.GetTypes
• Type.GetMethod
• MethodInfo.Invoke

Primero, carga el conjunto por su ruta, luego obtiene el tipo (clase) de él por su nombre, luego obtiene el método de la clase por su nombre nuevamente y finalmente llama al método con los parámetros relevantes.

Answer 4

El artículo es un poco más antiguo, pero sigue siendo aplicable para crear una capa de extensibilidad dentro de su aplicación:

Permita que los usuarios agreguen funcionalidad a sus aplicaciones .NET con macros y complementos

Answer 5

Sí, ++ a Matt y System.AddIn (un artículo de dos partes de la revista MSDN sobre System.AddIn está disponible here y here ). Otra tecnología que quizás quiera ver para tener una idea de dónde se puede encontrar el .NET Framework en el futuro es el Marco de Extensibilidad Administrado actualmente disponible en formato CTP en Codeplex.

Answer 6

Un consejo es cargar todos los complementos y demás en un AppDomain propio, ya que el código que se ejecuta puede ser potencialmente malicioso. Un AppDomain propio también se puede usar para "filtrar" ensamblajes y tipos que no desea cargar.

AppDomain domain = AppDomain.CreateDomain("tempDomain");

Y para cargar un ensamblado en el dominio de la aplicación:

AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyPath);
Assembly assembly = domain.Load(assemblyName);

Para descargar el dominio de la aplicación:

AppDomain.Unload(domain);

Answer 7

El siguiente fragmento de código (C #) construye una instancia de cualquier clase concreta derivada de Base encuentra en las bibliotecas de clases (* .dll) en la ruta de la aplicación y las almacena en una lista.

using System.IO;
using System.Reflection;
List<Base> objects = new List<Base>();
DirectoryInfo dir = new DirectoryInfo(Application.StartupPath);
foreach (FileInfo file in dir.GetFiles("*.dll"))
{
Assembly assembly = Assembly.LoadFrom(file.FullName);
foreach (Type type in assembly.GetTypes())
{
if (type.IsSubclassOf(typeof(Base)) && type.IsAbstract == false)
{
Base b = type.InvokeMember(null,
BindingFlags.CreateInstance,
null, null, null) as Base;
objects.Add(b);
}
}
}

Editar: Las clases a las que se refiere Matt son probablemente una mejor opción en .NET 3.5.