Arquitectura tipo complemento en .NET

Estoy tratando de implementar un complemento como aplicación. Sé que ya hay varias soluciones, pero esto solo será una prueba del concepto, nada más. La idea sería hacer que la aplicación principal de la aplicación sea casi sin rasgos por defecto y luego permitir que los complementos se conozcan unos a otros, haciendo que implementen todas las características necesarias.Arquitectura tipo complemento en .NET

Un par de cuestiones surgen:

Quiero que los plugins en tiempo de ejecución a saber el uno del otro a través de mi solicitud. Eso no significa que en el momento del código no podrían hacer referencia a los ensamblajes de otros complementos para que puedan usar sus interfaces, solo esa inicialización de la característica del complemento debería ser siempre a través de mi aplicación principal. Por ejemplo: si tengo ambos plugins X e Y cargados y Y quiere usar las características de X, debería "registrar" su interés a través de mi aplicación para usar sus características. Tendría que tener una especie de "diccionario" en mi aplicación donde almaceno todos los complementos cargados. Después de registrarme para obtener mi interés en mi aplicación, el complemento Y obtendría una referencia a X para poder usarlo. ¿Es este un buen enfoque?
Al codificar el complemento Y que usa X, necesitaría hacer referencia al ensamblaje de X, así que puedo programar contra su interfaz. Eso tiene el problema de versionar. ¿Qué pasa si codigo mi complemento Y contra una versión desactualizada del complemento X? ¿Debo usar siempre un lugar "central" donde estén todos los ensamblajes, teniendo siempre las versiones actualizadas de los ensamblajes?

¿Hay algún libro que trate específicamente con este tipo de diseños para .NET?

Gracias

edición: creo que la gente se están alejando de las 2 preguntas que hice. Puedo echar un vistazo a MEF y #develop, pero me gustaría obtener respuestas específicas a las preguntas que hice.

Fuente

2010-05-07 devoured elysium

Recomiendo buscar en MEF, que es nuevo pero parece muy prometedor. –

@Matt - creo que debería poner esto como una respuesta - eso es exactamente lo que iba a decir –

Ya he oído hablar de MEF, pero como se dice en el PO, mi idea no es utilizar un marco ya construido sino implementar yo mismo. No necesita algo muy complejo. –

Mire en el espacio de nombres System.AddIn. Es un nivel un poco más bajo que MEF, por lo que debe darle la experiencia de "implementarlo por mí mismo" que está buscando.

Fuente

2010-05-07 21:59:19

Enlaces útiles: [MEF versus AddIn] (http://stackoverflow.com/questions/835182/choosing-between-mef-and-maf-system-addin) y [MSDN System.AddIn] (http: // msdn. microsoft.com/en-us/library/gg145020(v=vs.100).aspx) –

Una vez que lo hice usando this example. Me encantó, pero fue hace un par de años, creo que podría haber mejores soluciones ahora. Mientras recuerde, la idea básica fue que hay una clase abstracta en su programa, y sus complementos heredan esa clase y se compilan como DLL ... o algo similar usando Interfaces. De todos modos ese enfoque funcionó bien para mí. Más tarde agregué un sistema de archivos vigilante para que pudiera cargar esos complementos de DLL mientras se está ejecutando.

To load an Assembly

To get the types the assembly exposes

Fuente

2010-05-07 22:18:33 m0s

Justo lo que iba a decir. Se agregaron algunos enlaces a las páginas de interés de MSDN. – Skizz

Sí, pero ese es un ejemplo un tanto simplista. Solo reflejo básico y diseño OO simple. –

Sí, es ... la única razón que sugerí es porque es capaz de resolver los problemas que especificó anteriormente ... con esfuerzo, por supuesto ... tendría que escribir un sofisticado administrador de complementos. Si estás buscando algo fuera de la caja, simplemente ve con MEF como todos sugirieron ... parece ser muy poderoso. – m0s

Hay un buen libro en la construcción de lo que busca: la disección de una aplicación de C#: Dentro SharpDevelop. Aquí hay un enlace: http://www.icsharpcode.net/OpenSource/SD/InsideSharpDevelop.aspx

La aplicación SharpDevelop está completamente basada en complementos y el libro habla sobre cómo la construyeron, las trampas que enfrentaron y cómo se sobrepusieron. El libro está disponible gratuitamente en el sitio, o puede comprarlo también.

Fuente

2010-05-07 22:39:29

Recomiendo mirar en MEF. Esta es una nueva forma de hacer complementos en .NET. Es la forma recomendada de hacer nuevos complementos para VS2010, por ejemplo. No lo he usado yo mismo, pero lo que he estudiado se ve genial.Añadiendo esto como una respuesta a la insistencia de los demás :)

Fuente

2010-05-07 23:38:14

Ver http://stackoverflow.com/questions/835182/choosing-between-mef-and-maf-system-addin. MEF no es un marco para crear complementos. – cdiggins

Sobre las dos cuestiones específicas que Exposed:

1) No estoy seguro de lo que estás tratando de lograr, pero mi conjetura es que usted quiere tener Inicialización lenta de las características, y tal vez la carga diferida de complementos. Si ese es el objetivo, lo que estás proponiendo podría funcionar. Por lo tanto, podría funcionar así:

El complemento Y proporciona una lista de las características que necesita usar (podría realizarse, por ejemplo, a través de una implementación de interfaz específica oa través de un manifiesto xml).
El complemento X implementa una API que permite inicializar una característica, con un método como Initialize (featureId).
La aplicación host obtiene la lista de características requerida por Y, carga/inicializa el complemento X y llama a Inicialice para cada característica.
La aplicación host también proporciona una GetFeature() método que Y puede utilizar para obtener una referencia a un objeto 'característica', que se implementa en X.

Sin embargo, si el plugin Y tiene acceso directo a la API X, creo que es innecesario tener toda esa infraestructura para registrar funciones. Puede acceder a las características de X directamente utilizando la API X, e Y se encargaría de la inicialización lenta de cada función cuando sea necesario. Por ejemplo, Y podría simplemente llamar a SomeXFeature.DoSomething(), y la implementación de esa clase inicializaría la característica la primera vez que se utiliza.

2) Si la API de un conjunto cambia, cualquier conjunto que dependa de él puede romperse. Los complementos son solo ensamblajes que dependen de otros ensamblajes, por lo que también se romperán. Aquí hay algunas cosas que puede hacer para aliviar este problema.

Asigne un número de versión a cada complemento. Esto podría ser solo la versión de ensamblaje.
Al cargar un complemento, asegúrese de que todas las dependencias se puedan satisfacer adecuadamente (es decir, todos los complementos de los que depende deben estar presentes y tener la versión requerida). Se niega a cargar el complemento si las dependencias no pueden ser satisfechas.
Implemente una herramienta de administración de complementos, que se utilizará para todas las operaciones de instalación/desinstalación de complementos. El administrador puede verificar dependencias e informar errores cuando intenta instalar complementos con dependencias insatisfechas o cuando intenta desinstalar un complemento del que dependen otros complementos.

Soluciones similares se utilizan en el marco Mono.Addins. En Mono.Addins, cada complemento tiene un número de versión y una lista de complementos/versiones de los que depende. Al cargar un complemento, el motor de complemento asegura que también se carguen todos los complementos dependientes con las versiones correctas. También proporciona una API y una herramienta de línea de comandos para administrar la instalación de complementos.

Fuente

2010-08-06 17:58:46

Arquitectura tipo complemento en .NET

Respuesta

Cuestiones relacionadas