Hi ihr,

Frage steht eigentlich schon im Titel - womit geht das am Besten? Ziel ist eigentlich, dass ich eine Basisanwendung erstelle, und anschließend alles über Zusatzplugins gelöst wird, die auch nach belieben hinzugefügt oder weggelassen werden können. Das Kernprogramm übernimmt nur die Steuerung der Kommunikation der einzelnen Elemente und verwaltet die Module.

Womit könnte ich sowas in CSharp + WPF umsetzen?

Na da fallen mir spontan gleich 2 Kürzel ein, mit denen sich das Problem einfachst lösen läßt:
WAF und MEF

Die Lernkurve ist nicht ganz klein, aber es lassen sich damit dann wirklich einfach Anwendungen erstellen, die über Plugins erweitert werden können. Zumindest MEF nutzt Microsoft selbst, um ihr Visual Studio 2010 mit Addins erweiterbar zu machen.

Ich nutze beides seit einiger Zeit zusammen und bin echt begeistert.

Ein Plugin-System ist in .NET mittels ein paar Zeilen zu machen.
Man braucht lediglich ein Interface, welches das Plugin implementieren muss. Mittels Reflection kann man dann alle alle Assemblies mit den Plugins (z.B. aus einem bestimmten Verzeichnis) laden, dort nach Klassen suchen die dieses Interface implementieren, diese instanzieren und that's it.

Das finden der entsprechenden Klassen ist mit LINQ ein Einzeiler: Assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(YourInterface)))

Danke euch beiden...

@Phoenix: SO einfach? Und mit dieser Methode kann ich auch dynamisch Assemblies laden? Ich bin mir noch nicht ganz sicher, wie ich das genau umsetze. Eigentlich möchte ich dem User die Möglichkeit geben, für eine Aktion zwischen mehreren Modulen wählen zu können und ggf. ein Standardmodul zu definieren. Ähnlich wie Android, welches ja auch komplett modular aufgebaut ist.

Naja, ein paar Zeilen mehr sinds schon.

Erstmal alle Files die mit .dll enden laden:

markieren

Code:

foreach (var file in Directory.GetFiles(AppDomain.CurrentDomain.RelativeSearchPath, "*.dll"))
{
   try
   {
      Assembly.LoadFrom(file);
   }
   catch { } // fine here. Existing .dll could be a native library
}

Nun hast Du alle Assemblies verfügbar und kannst daraus alle Typen ermitteln, die Du benötigst. Dazu gibts ne kleine Helfermethode:

markieren

Code:

private static List<Type> FindTypes<T>()
{
  return AppDomain.CurrentDomain.GetAssemblies()
    .Select(a => a.GetTypes())
        .SelectMany(a =>
          a.Where(t => t.IsClass && !t.IsAbstract && typeof(T).IsAssignableFrom(t)))    
    .ToList();
}

Sagen wir Du hast ein Interface namens IMyPlugin und das definiert ne Methode Load() dem Du Deinen Plugin-Host übergibtst, dann initialisierst Du alle Plugins so:

markieren

Code:

foreach (var pluginType in FindTypes<IMyPlugin>())
{
    IMyPlugin instance = (IMyInterface) Activator.CreateInstance(pluginType);
    instance.Load(this); // oder whatever halt  
}

In load können die sich dann in ne List<IMyPlugin> auf dem Host legen oder Du merkst Sie Dir irgendwie anders.

Wenn Du nicht gleich alle instanzieren willst kannst Du natürlich auch einfach die Typen aus der Liste anzeigen und nur einzelne instanzieren. Mittels Custom Attributen kannst Du auch noch weitere Informationen zu den Plugins ausgeben etc. .NET ist da ziemlich mächtig *g*

Hm... Ich bin grad über Prism gestolpert - klingt eigentlich auch interessant...

//Edit: Ach... Danke fürs Beispiel...

Was mir in dem Zusammenhang noch einfällt, wäre Caliburn Micro.

Also mein erster Tipp wäre auch Prism gewesen. Der zweite Caliburn.Micro mit MEF.

Danke euch - auch wenn ich noch ein wenig Schlucke, was die Lernkurve von Prism angeht.