Microsoft Extensibility Framework in der Praxis

Das Microsoft Extensibility Framework, kurz MEF, ist seit der Framework Version 4.0 fester Bestandteil des .NET Frameworks. Ganz kurz gefasst dient es dazu, Klassen auszulagern, z.B. in eine DLL Datei. Es ermöglicht eine lose Kopplung von Komponenten und eignet sich damit hervorragend für die Realisierung einer Plugin-Architektur. Microsoft selbst setzt das MEF Framework  bereits intensiv für Visual Studio 2010 ein.

Wer einfach nur eine ganz knappe HowTo-Anleitung sucht, wie das MEF Framework in einem eigenen Projekt eingesetzt werden kann, ist mit diesem Blogeintrag fündig geworden.

Also, Schritt für Schritt:

• Erstellen sie eine neue Visual Studio 2010 Solution, nennen sie sie „MEF Beispiel“
• Fügen sie dieser Solution ein neues Projekt hinzu (WPF oder Forms, spielt keine Rolle), nennen sie es „Hostanwendung“
• Erstellen sie einen Verweis auf System.ComponentModel.Composition
• Fügen sie der Solution ein neues Klassenbibliothek-Projekt hinzu, nennen sie es „Interfaces“
• Legen sie in diesem ebenfalls einen Verweis auf System.ComponentModel.Composition an
• Implementieren sie folgenden Code in dieser Klassenbibliothek:

<InheritedExport(GetType(IhreKlasseInterface))>
Public Interface IhreKlasseInterface
'// InheritedExport Tag wird vom MEF zur Verfügung
'// gestellt und bewirkt das alle Klassen, die dieses
'// Interface implementieren automatisch vom
'// MEF Framwork exportiert werden.

      Sub SagHallo()

End Interface

• Fügen sie der Solution ein neues Klassenbibliothek-Projekt hinzu, nennen sie es „ExterneKlassen“
• Auch diesem  Projekt einen Verweis auf System.ComponentModel.Composition hinzufügen
• Außerdem auch einen Verweis auf das „Interfaces“ Projekt  in der Solution anlegen, damit sie auf das eben erstellte Interface zugreifen können
• Implementieren sie nun folgende Klasse im Projekt „ExterneKlassen“

Class IhreKlasse
Implements IhreKlasseInterface
'// Implementiert das Interface aus der
'// "Interfaces" Solution. Dazu müssen
'// sie den Verweis korrekt angelegt haben!

Public Sub SagHallo() Implements IhreKlasseInterface.SagHallo

       MsgBox("Hallo!")

End Sub

End Class

• Zum Einbinden dieser Klasse in ihr Hauptprojekt „Hostanwendung“ müssen sie nun ebenfalls einen Verweis auf das Projekt „Interfaces“ hinzufügen
• Implementieren sie dann Folgendes in ihrer „Hostanwendung“

Class BasisKlasse

<Import(GetType(Interfaces.IhreKlasseInterface))>
Private _AusgelagerteKlasse() As Interfaces.IhreKlasseInterface

'// Das MEF Framework wird in diese Variable
'// die ausgelagerte Klasse instanzieren

Private _dcatalog As DirectoryCatalog = Nothing

Public Sub LoadPlugins(ByVal path As String)

_dcatalog = New DirectoryCatalog(path)

'// Legt einen neuen Katalog an, d.h.
'// hier werden Verweise auf alle
'// gefundenen DLL's im angegebenen
'// Verzeichnis angelegt

Dim container = New CompositionContainer(_dcatalog)

'// Legt einen neuen Container an, in
'// den bei Bedarf mehrere Kataloge
'// eingeladen werden können

Dim batch = New CompositionBatch()

'// Führt mehrere Kompositionen
'// nacheinander aus

batch.AddPart(Me)

'// Fügt meine eigene Klasseninstanz
'//  zum Container hinzu
'//(Das ist schließlich die Klasse, die
'// zur Laufzeit die ausgelagerte
'// Klasse importiert!)

batch.AddPart(_dcatalog)

container.Compose(batch)

'// Führt den Import durch. d.h.
'// nachdem dieser Befehl ausgeführt
'// wurde, befindet sich in der
'// privaten Variable _AusgelagerteKlasse
'// eine Instanz der ausgelagerten Klasse
'// "IhreKlasse"

AusgelagerteKlasse.SagHallo()

'// Ruft die ausgelagerte Klasse auf.
'// Voilà!

End Sub

End Class

• Voilà!

Was haben wir nun erreicht?
Ihre Hostanwendung kann auf die Funktionalität ihrer „ExterneKlassen“ Bibliothek zugreifen, ohne einen direkten Verweis drauf zu benötigen!

(Die Funktionalität dieser Bibliothek ist aber noch ausbaufähig… ;))

Beide Projekte müssen lediglich auf ihr „Interfaces“ Projekt referenzieren, um  auf das gemeinsame Interface zugreifen zu können.

Das MEF Framework sorgt im Hintergrund dafür, dass die „ExterneKlassen“ Bibliothek transparent zur Laufzeit in der Hostanwendung zur Verfügung steht.

Diese Technik ist sicher nicht der schlechteste Ausgangspunkt für eine Pluginarchitektur, auch wenn natürlich deutlich wird, dass das Interface in diesem Beispiel  nur Demonstrationszwecken dient und in dieser Form sicher nicht produktiv eingesetzt werden kann.