Archive. Posts from 2004 to 2016, kept as they were written. My current blog is at dariuszparys.com.

Im .NET Framework 3.5 findet man unter dem Namespace System.AddIn ein Objektmodell mit dem man Anwendungen um ein Plug-In Modell erweitern kann.

System.AddIn arbeitet hier sehr strikt mit einer Interface Definition. Die Definition ist die Grundlage für entsprechende Adapterklassen, die letztendlich dafür verantwortlich sind den View zu aktualisieren. Der View auf beiden Seiten der Pipeline ist dann einmal mit dem Host, zum anderen mit dem AddIn verbunden.

shot1

Die Adapter und der Contract sind somit nicht mit dem Host und nicht mit dem AddIn direkt referenziert, sondern werden durch die System.AddIn Infrastruktur auf Basis von Attributen und Ableitungen entsprechend geladen und instanziert.

Um ein Add-In zu entwickeln muß der Add-In Entwickler nur folgende Abhängigkeiten beachten:

  1. Man muß den entsprechenden View des Contracts referenzieren, eine abstrakte Basisklasse die überschrieben wird.
  2. Das Add-In wird noch Attributiert, um dem Framework mitzuteilen, das es sich hier um ein Add-In handelt, das über die Infrastruktur instanziert werden kann.
  3. Kopieren des Add-In Assemblies in die entsprechende Verzeichnisstruktur. Der Host kann dann das Add-In laden.

Das war es schon.

Hier ein kleines Beispiel einer Add-In Implementierung.

using System;
using System.AddIn;
using Demo.View.Addin;

namespace Demo.Addin.Number2
{
    [AddIn( "Hello World (TechTalk Version)", Version="1.0.0.0")]
    public class TechTalkHelloWorld : HelloWorld
    {
        public override string SayHelloWorld()
        {
            return "Hallo TechTalk!";
        }
    }
}

HelloWorld ist der View von dem der Entwickler ableitet. Auf der Host-Seite gibt es nun den entsprechenden Aktivierungscode für Add-Ins. Im einzelnen hat man hier mehrere Möglichkeiten um ein Add-In zu instanzieren:

  • In welchem Security Kontext soll das Add-In laufen?
  • Soll jedes Add-In eine eigene AppDomain erhalten?
  • Sollen mehrere Add-Ins zusammen in eine AppDomain instanziert werden um entsprechend miteinander zu kommunizieren?
  • Soll das Add-In in einen eigenen Prozess ausgelagert werden?
  • Soll das Add-In ein eigenes Permission-Set erhalten?

Für jeden Anwendungsfall kann man entsprechend die optimalen Hosting-Parameter auswählen und implementieren.

Hier ein Beispiel um ein Add-In zu finden und zu instanzieren.

// pipeRoot ist das Verzeichnis in welchem die Infrastruktur sucht
Collection<AddInToken> tokens = AddInStore.FindAddIns( typeof( HelloWorld ), pipeRoot );

// ...
// Code zum anzeigen der verfügbaren Add-Ins und Auswahl-Logik
// ...

// das ausgewählte Token wird referenziert
AddInToken helloWorldToken = tokens[ number - 1 ];

// Instanzieren des Add-Ins
HelloWorld helloWorld = helloWorldToken.Activate<HelloWorld>( AddInSecurityLevel.Host );

// Nutzen des Add-Ins
Console.WriteLine( helloWorld.SayHelloWorld() );

In Zeile 2 erhält man alle verfügbaren Add-Ins die das Interface HelloWorld implementiert haben.

Zeile 12 instanziert das Add-In. In diesem Fall wird das Add-In in einer eigenen AppDomain im gleichen Prozess des Hosts instanziert.

Man erkennt schon das Add-Ins dementsprechend Remotable sein müssen, da .NET Remoting als Kommunikationsinfrastruktur genommen wird.

Um das Add-In nun in einen eigenen Prozess zu instanzieren, kann man folgende Zeilen schreiben.

AddInToken helloWorldToken = tokens[ number - 1 ];

AddInProcess process = new AddInProcess();
process.Start();
HelloWorld helloWorld = helloWorldToken.Active<HellWorld>( process,
                            AddInSecurityLevel.Host );

Console.WriteLine( helloWorld.SayHelloWorld() );

Beim Benutzen des Add-Ins wird entsprechend ein neuer Prozess hochgezogen. Die Infrastruktur stellt hierzu den Host AddInProcess32.exe zur Verfügung. Ein Screenshot des Task Managers zeigt diesen instanzierten Prozess beim Ausführen des Add-Ins.

shot2

Die Kommunikation zwischen dem gestarteten Prozess und dem Host läuft dann über den IPC Channel von .NET Remoting. Die Inter-Process-Communication des Betriebssystems erlaubt es direkt zwischen AppDomains auf der gleichen physikalischen Maschine performant zu kommunizieren und .NET Remoting bietet eben diesen Channel an, der dann auch konsequent von AddInProcess32.exe genutzt wird.

Das System.AddIn Objektmodell erlaubt es nun mit relativ einfachen Mitteln, eine Plugin Architektur in eigene Anwendungen einzubauen, mit dem Vorteil der Versionierung und der Isolation durch die verfügbaren Aktivierungsmöglichkeiten.

Es lohnt allemal einen Blick auf den Namespace System.AddIn zu werfen, auch wenn man bisher noch nicht an ein Plug-In Modell für seine eigene Anwendunge gedacht hat.