Un semplice contenitore IoC per un piccolo sistema di plugin

Question

Sto progettando un semplice framework di plugin per un'applicazione .NET 3.5 (WinForms).

La nostra applicazione attuale deve iniziare a supportare il caricamento dinamico e il "collegamento" di diversi "plug-in"/"estensioni" che sono sconosciuti all'applicazione in fase di compilazione.

Queste estensioni sarebbero "agganciate" a diverse aree dell'applicazione, come ad esempio i gestori di eventi di determinate classi.

Per esempio (semplificato):

public class SomeSystem 
{ 
    public event Action<string> Completed; 

    public event Action<string> Failed; 

    public event Action<string> Stopped; 
} 

Un uso caso mi piacerebbe avere è per gli sviluppatori di essere in grado di definire gestori per tali eventi in un assembly plug-in, senza avere l'applicazione sapere su di loro .

Dalla mia conoscenza, i contenitori IoC consentono di rilevare dinamicamente oggetti in fase di runtime e di registrarli in un contenitore.

È un contenitore IoC in grado di eseguire questo aggancio anche in vari eventi? O questo compito è più facile da fare senza un simile quadro?

Come si fa a progettare come integrare un contenitore IoC per tale compito? (supponiamo che ci siano più punti di estensione, come eventi diversi che possono essere usati per registrarsi).

Alcune domande mi sono trovato a chiedere:

1. E 'comune che il plugin stesso offrono un Registro metodo per fare la registrazione?
2. Se l'IoC esegue la registrazione? (come si fa di solito?)
3. In che modo è possibile definire facilmente i punti di estensione quando si utilizza un contenitore IoC?

Answer 1

probabilmente avrete bisogno di guardare MEF. Permette tutte le cose che hai chiesto. La terminologia utilizzata (ComposableParts, Exports, ecc.) Inizialmente confonde, ma è molto semplice da usare.

È comune che il plugin stesso offra un metodo di registrazione per eseguire la registrazione ?

MEF fa in modo che l'applicazione esegua il lavoro di ricerca e registrazione di plug-in. Il plugin ha solo bisogno di implementare un'interfaccia che dice "Io sono un plugin che può fare X".

Se l'IoC esegue la registrazione? (come è fatto di solito?)

Un'applicazione che utilizzerà i plug-in MEF è in grado di specificare come caricherà i plug-in. Questo potrebbe essere ricercando una directory per le DLL, leggendo il file di configurazione per un elenco di nomi di assembly, controllando il GAC - qualsiasi cosa. E 'totalmente estendibile (in che è possibile scrivere le proprie classi di ricerca)

Come può punti di estensione essere facilmente definito quando si utilizza un contenitore CIO ?

MEF utilizza le interfacce per definire un contratto tra l'applicazione e il plug-in.

Answer 2

Questa risposta sarà specifica per il mio contenitore.

La nostra applicazione attuale deve iniziare a supportare il caricamento dinamico e il "collegamento" di diversi "plug-in"/"estensioni" che sono sconosciuti all'applicazione in fase di compilazione.

Per poterlo fare è necessario definire alcune interfacce di estensione che si inseriscono in una libreria di classi che verrà condivisa tra l'applicazione e tutti i plug-in.

Per esempio, se vuoi le applicazioni per essere in grado di aggiungere cose al menu delle applicazioni è possibile creare la seguente interfaccia:

class ApplicationMenu 
{ 
    // The "File" menu 
    IMenuItem File { get; } 
} 

interface IMenuRegistrar 
{ 
    void Register(ApplicationMenu menu); 
} 

Il che significa che il vostro plugin può creare la seguente classe:

[Component] 
public class CoolPluginMenuRegistrar : IMenuRegistrar 
{ 
    public void Register(ApplicationMenu menu) 
    { 
     menu.File.Add("mnuMyPluginMenuName", "Load jokes"); 
    } 
} 

L'attributo [Component] è utilizzato dal mio contenitore in modo che possa rilevare e registrare automaticamente le classi per voi.

Tutto quello che devi fare per registrare tutti i punti di estensione, come quello di cui sopra è questo:

public class Program 
{ 
    public static void Main(string[] args) 
    { 
     var registrar = new ContainerRegistrar(); 
     registrar.RegisterComponents(Lifetime.Transient, Environment.CurrentDirectory, "MyApp.Plugin.*.dll"); 
     var container = registrar.Build(); 

     // all extension points have been loaded. To load all menu extensions simply do something like: 

     var menu = GetMainMenu(); 
     foreach (var registrar in container.ResolveAll<IMenuRegistrar>()) 
     { 
      registrar.Register(menu); 
     } 
    } 
} 

Queste estensioni sarebbero "agganciato" in diverse aree di applicazione, come ad esempio ADED come gestori di eventi di alcune classi. Da quanto ne so, i contenitori IoC consentono di scoprire dinamicamente oggetti in fase di runtime e di registrarli in un contenitore.

Sì. Ottieni tutto questo.

È un contenitore IoC in grado di eseguire questo aggancio anche in vari eventi? O questo compito è più facile da fare senza un simile quadro?

Sì. Ho un meccanismo per eventi incorporato. Inserire le classi di eventi (classi .NET regolari in librerie di classi condivise). Il Basta iscriversi su di loro mediante l'attuazione di un'interfaccia:

[Component] 
public class ReplyEmailNotification : ISubscriberOf<ReplyPosted> 
{ 
    ISmtpClient _client; 
    IUserQueries _userQueries; 

    public ReplyEmailNotification(ISmtpClient client, IUserQueries userQueries) 
    { 
     _client = client; 
     _userQueries = userQueries; 
    } 

    public void Invoke(ReplyPosted e) 
    { 
     var user = _userQueries.Get(e.PosterId); 
     _client.Send(new MailMessage(user.Email, "bla bla")); 
    } 
} 

e pubblicare eventi:

DomainEvent.Publish(new ReplyPosted(user.Id, "This is a subject")); 

Gli eventi possono essere gestiti da alcun plugin, purché:

1. Impossibile accedere la classe evento
2. Sono stati registrati nel contenitore ([Component] o registrazione manuale)
3. Implementa ISubscriberOf<T>

E 'comune che il plugin stesso offrono un metodo Registrati per fare la registrazione?

Sì. Attraverso diverse interfacce che sono definite come punti di estensione in un assembly condiviso.

Se l'IoC esegue la registrazione? (come si fa di solito?)

Sì. Se il contenitore lo fornisce.

In che modo è possibile definire facilmente i punti di estensione quando si utilizza un contenitore IoC?

È possibile leggere su di esso in modo più dettagliato qui: http://www.codeproject.com/Articles/440665/Having-fun-with-Griffin-Container