Pluginfähige Anwendung

  • C#

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von nikeee13.

    Pluginfähige Anwendung

    Moin,

    Ich hab versucht das PluginSystem von Mikeb in C# umzubauen, folgendermaßen sieht es aus;


    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Windows.Forms;
    7. namespace Circum
    8. {
    9. public class PlugInConnector
    10. {
    11. public static IPlugin LoadPlugIn(string strFile)
    12. {
    14. IPlugin vPlugIn = default(IPlugin);
    15. System.Reflection.Assembly a = System.Reflection.Assembly.LoadFile(strFile);
    17. Type[] types = a.GetTypes();
    19. foreach (Type pType in types)
    20. {
    21. //hier wird versucht die dll zu laden.
    22. //dies funktioniert nur, wenn die dll auch das selbe interface implementiert
    23. //wie der host vorgiebt
    24. try
    25. {
    26. vPlugIn = (IPlugin)a.CreateInstance(pType.FullName);
    27. //dll ist ein gültiges plugin
    28. return vPlugIn;
    30. }
    31. catch(Exception ex)
    32. {
    33. MessageBox.Show(ex.Message);
    34. }
    35. }
    36. //keine gültige dll gefunden
    37. return null;
    38. }
    39. }
    40. }

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    6. namespace Circum
    7. {
    8. public interface IPlugin
    9. {
    10. string PluginName { get; }
    11. string PluginAutor { get; }
    12. string PluginDescription { get; }
    13. string PluginHostString { get; }
    14. string PluginVersion { get; }
    15. }
    16. }

    C#-Quellcode

    1. foreach(string plugin in Directory.GetFiles(Application.StartupPath + @"\Plugin\"))
    2. {
    3. PluginList.Add(PlugInConnector.LoadPlugIn(plugin));
    4. }
    5. MessageBox.Show(PluginList[0].PluginName); //Einfacher Test


    Plugin: (Hat auch IPlugin)

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    6. namespace Circum
    7. {
    8. public class YouTube : IPlugin
    9. {
    10. public string PluginName { get { return "YouTube"; } }
    11. public string PluginAutor { get { return "Circum-Team"; } }
    12. public string PluginDescription { get { return "Implements Host:YouTube"; } }
    13. public string PluginHostString { get { return "youtube"; } }
    14. public string PluginVersion { get { return "1.1"; } }
    16. public YouTube()
    17. {
    18. }
    20. }
    21. }


    Leider bekomme ich beim Laden immer die Fehlermeldung;

    Der Konstruktor für Circum.IPlugin wurde nicht gefunden
    Das Objekt Circum.YouTube kann nicht in Circum.IPlugin umgewandelt werden.



    Was habe ich falsch gemacht?

    Danke

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „nikeee13“ ()

    Quellcode

    1. foreach (Type type in types)
    2. {
    3. if (typeof(IPlugin).IsAssignableFrom(type))
    4. {
    5. //hier wird versucht die dll zu laden.
    6. //dies funktioniert nur, wenn die dll auch das selbe interface implementiert
    7. //wie der host vorgiebt
    8. try
    9. {
    10. vPlugIn = (IPlugin)a.CreateInstance(pType.FullName);
    11. //dll ist ein gültiges plugin
    12. return vPlugIn;
    14. }
    15. catch(Exception ex)
    16. {
    17. MessageBox.Show(ex.Message);
    18. }
    19. }
    20. }
    To make foobar2000 a real random music player, I figured out the only way to achieve this is to use Windows Media Player.

    “At some point in time, you recognize that knowing more does not necessarily make you more happy.”

    Autorinformationen würde ich in ein CustomAttribute packen, da du dann keine Instanz der Plugin-Klasse brauchst, um diese Infos auszulesen.

    Außerdem gibt es in .NET bessere Methoden, ein Pluginsystem aufzubauen. Ich bevorzuge MEF.
    Ein einfaches Plugin-System mit verschiedenen Plugin-Quellen lässt sich einfach in ein paar Zeilen realisieren:
    just-about.net/mef-tutorial

    stackoverflow.com/questions/20…ere-can-i-learn-about-mef

    Übrigens kann eine DLL auch mehrere öffentliche IPlugin-Implementierungen haben - das bleibt bei deiner Lösung vollkommen raus.
    Bei MEF benötigst du nur ein ImportMany-Attribut vor z.B. einer List<IPlugin>. Dann noch die Plugins laden und alles funktioniert automatisch. ;)
    Von meinem iPhone gesendet

    @Chrisber²: Es kommt zumindest keine Fehlermeldung mehr, aber das abrufen der Property in der Messagebox bleibt trotzdem aus, es wird null zurückgegeben.

    Ich kenn mich mit sowas garnicht aus, deswegen verzeih mir ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ThuCommix“ ()

    Was machst du es dir so schwer?
    Hättest nur den ersten Artikel überfliegen müssen, den ich gepostet habe. Mit dem MEF dauert das 2 Minuten.

    Man hat .NET 3.5/4 nicht umsonst. Da gibt es sowas schon vom Framework aus. Wenn man unter .NET 3.5 arbeitet, kann man sich MEF von Codeplex ziehen.
    Eure Methoden sind etwas "veraltet". ;)

    In der Klasse, in der die Plugins sein sollen:

    C#-Quellcode

    1. [ImportMany(typeof(IPlugin))] //Festlegen, dass dieses Feld mit importierten IPlugin-Instanzen gefüllt werden soll
    2. private IPlugin[] _plugins = null;
    4. public void LoadPlugins()
    5. {
    6. var catalog = new DirectoryCatalog("./Plugins/"); //Eine Import-Quelle angeben (gibt noch andere)
    7. var container = new CompositionContainer(catalog); // Quelle zum Container hinzufügen
    8. container.ComposeParts(this); //Alle Imports aus den Exports hereinladen (hier werden die Plugins geladen)
    9. #if DEBUG
    10. foreach (IPlugin contract in _plugins)
    11. { //Zu testzwecken mal alles ausgeben.
    12. Debug.WriteLine("Plugin von Autor geladen: ");
    13. Debug.WriteLine(contract.AuthorName);
    14. }
    15. #endif
    16. }
    (Das ersetzt also die komplette PluginConnector-Klasse und das Teil, das die Methode aufruft)

    Klassen, die Plugins sein sollen, müssen dann IPlugin implementieren und mit dem Attribut gekennzeichnet sein:

    C#-Quellcode

    1. [Export(typeof(Circum.IPlugin))] //Festlegen, dass diese Klasse exportiert werden kann


    Es werden dann alle IPlugin-Teile geladen, die sich in den Assemblies im Unterordner Plugins befinden. Von jedem Plugin landet dann eine Instanz im Array _plugins. Das Array kannst du natürlich auch durch eine List<T> ersetzen.

    Die Namespaces kannst du dir über die Auflösen-Funktion holen.

    Fertig.

    Edit:
    Tutorial hier:
    vb-paradise.de/allgemeines/tip…utorials/allgemein/87231-
    Von meinem iPhone gesendet

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „nikeee13“ ()

    Danke danke danke! Versteh mich nicht falsch, ich habe bereits das hier abgearbeitet: mef.codeplex.com/wikipage?titl…iner&referringTitle=Guide

    Ich wollte nur trotzdem wissen wieso das erstere nicht funktioniert hat ;)

    Funktioniert :>
    Bilder

    • Unbenannt.png

      32,82 kB, 451×322, 182 mal angesehen

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „ThuCommix“ ()

    Mist doch noch eine Frage, gibt es eine Möglichkeit Plugins zu unloaden? Wie ich bis jetzt gelesen habe, ist das eigentlich in MEF nicht vorgesehen, brauche es aber dringend um z.B Plugins zu aktualisieren oder zu Entfernen.

Facebook