Architecture Plugin - Faire un formulaire parent MDI Conscient des enfants dans DLLs

Question

J'expérimente avec une architecture de plug-in pour le système commercial interne de mon entreprise. J'ai réussi à lire tous les fichiers .DLL dans un dossier Plugin qui implémente une interface spécifique. Ce que j'essaie de comprendre, c'est la meilleure méthode de communication entre l'application mère MDI "hôte" et les formulaires qui seront dans les fichiers .DLL que j'ai l'intention de créer des enfants MDI.

Actuellement, je reviens juste des objets ToolStripMenuItem des DLLs ajouter au parent MDI. J'ai également testé que les événements câblés dans les fichiers .DLL à ToolStripMenuItems se propagent au code dans les fichiers .DLL. J'ai également réussi à renvoyer un objet Form via l'interface et à ouvrir ce formulaire, car le dossier Plugin est "scanné".

Cependant, je ne suis pas certain que je ferais ces formes enfants MDI. En outre, toutes les autres formes vivant dans les .DLL devront également être des enfants MDI. J'ai créé un projet VS 2008 Addin juste pour voir ce qui se passe, et il semble que l'Addin accepte un objet Application sur lequel il ajoute à ToolStripMenuItems et effectue d'autres opérations. Le code pour construire le menu dans le fichier .DLL. C'est à l'opposé de ce que j'ai fait jusqu'ici, où le MDI demande un ToolStripMenuItem de chaque .DLL et ajoute l'objet retourné à son propre menu.

Est-ce que la conception de mon architecture de plugin pour accepter un objet d'application de la même manière la seule façon que je pouvais obtenir des formulaires pour ouvrir comme un enfant MDI? Est-ce que je demande d'autres maux de tête, actuellement inconnus, en ne passant PAS l'objet application au fichier .DLL?

Answer 1

Il y a quelques années, nous avons fait quelque chose de similaire. Comment nous avons géré cela en créant quelques interfaces qui ont été implémentées par un PluginManager et les Plugins.

Le Plugin Manager mis en œuvre une interface similaire à celle-ci:

''' <summary> 
'''The IPluginManager interface is implemented by whatever component manages your gui 
'''It provides a means for plugins to access GUI elements of the application 
''' </summary> 
Public Interface IPluginManager 

    ''' <summary> 
    '''The MDIForm property allows the plugin to display itself 
    '''inside of the application's main MDI form (ie. plugin.form.mdiparent=mdiform) 
    ''' </summary> 
    ReadOnly Property MDIForm() As Form 
    ReadOnly Property Toolbar() As ToolBar 

    ''' <summary> 
    '''Allows the plugin to request that the application's main menu be updated 
    ''' </summary> 
    ''' <param name="Menu">The menu to add to the main menu</param> 
    Sub UpdateMainMenu(ByVal Menu As Menu) 

    ''' <summary> 
    '''Allows the plugin to request that the application's workspace toolbar be updated 
    ''' </summary> 
    ''' <param name="Buttons">the collection of toolbar buttons to add to the toolbar</param> 
    Sub UpdateToolbarButtons(ByVal Buttons As ToolBar.ToolBarButtonCollection) 

End Interface 

Le Plugins mis en œuvre cette interface:

''' <summary> 
'''The IPlugin interface is implemented by all plugins 
'''It provides a standardized means for the pluginmanager 
'''to communicate with a plugin, without knowing the plugin explicitly 
''' </summary> 
Public Interface IPlugin 

    ''' <summary> 
    '''Allows the plugin to be intialized first before it asked to run 
    ''' </summary> 
    Sub Initialize() 

    ''' <summary> 
    '''Allows the pluginmanager to register itself with the plugin 
    '''so the plugin can listen to events from the pluginmanager 
    ''' </summary> 
    ''' <param name="PluginManager">A plugin manager that implements the IPluginManager interface</param> 
    Sub RegisterPluginManager(ByVal PluginManager As IPluginManager) 

    ''' <summary> 
    '''Requests the plugin to run its functionality 
    ''' </summary> 
    Sub Run() 

End Interface 

Une fois que l'application démarre, le PluginManager trouve tous les plugins disponibles (sons comme vous l'avez déjà fait) et ensuite instancie chaque plugin, en s'enregistrant avec chaque plugin. Le PluginManager initialise puis exécute le (s) plugin (s). Du côté plugin, lorsque le plugin est initialisé ou s'exécute (selon vos besoins), il vous suffit de définir la propriété MDIParent du plugin sur le MDIForm fourni dans l'interface IPluginManager. Et Viola!

Il s'agit d'un contrat assez simple entre les deux que vous pouvez facilement modifier ou développer.