Blog de Nico-pyright(c)

26
mars
2010

[MEF][C#] Un petit coup d’oeil au Managed Extensibility Framework

Un article de nico-pyright(c) Comments

MEF (Managed Extensibility Framework) est un framework développé par Microsoft qui permet de créer des applications extensible facilement.
Il fonctionne comme un système de plugin et est capable de composer une application en chargeant des extensions à des endroits prédéfinis. Cela permet d’étendre un logiciel sans avoir besoin de connaitre à l’avance le fonctionnement du plug-in, tant que le celui-ci respecte un contrat ; grâce à la fonctionnalité de découverte de MEF.

MEF fonctionne grâce à des annotations et des attributs.

L’attribut Export permet d’informer MEF qu’il se trouve en présence d’un plugin qui respecte un contrat particulier.
L’attribut Import permet d’indiquer à MEF qu’il doit se débrouiller pour nous fournir quelque chose qui respecte un contrat précis.

MEF est actuellement en développement (Preview 9 à l’heure où j’écris ces lignes), son API est susceptible d’évoluer.

Pour illustrer cette introduction, nous allons construire une petite application de démo.
Pour utiliser MEF, il suffit de récupérer le code à cet emplacement http://www.codeplex.com/MEF et de copier la DLL System.ComponentModel.Composition.dll.

Je créé une application Console que je nomme testMef puis 2 projet de type Class Library que je nomme HelloWorldService.Contract et HelloWorldService.

HelloWorldService.Contract contiendra l’interface suivante :

public interface IHelloWorldService
{
    string Hello(string who);
}

HelloWorldService contiendra le classe suivante :

public class HelloWorldService : IHelloWorldService
{
    public string Hello(string who)
    {
        return "Hello " + who;
    }
}

Dans mon application console, je crée une classe ClassicRunner qui va instancier mon service et appeler sa méthode Hello.

public class ClassicRunner
{
    public void Run()
    {
        IHelloWorldService helloWorldService = new HelloWorldService.HelloWorldService();
        Console.WriteLine(helloWorldService.Hello("Nico"));
    }
}

Nous introduisons ici une dépendance forte au projet HelloWorldService.

Je peux bien sur utiliser cette classe dans le point d’entrée de mon application console avec :

public class Program
{
    public static void Main(string[] args)
    {
        ClassicRunner classicRunner = new ClassicRunner();
        classicRunner.Run();
    }
}

Maintenant, faisons la même chose à la mode MEF.

La première chose à faire est de dire à MEF que la classe HelloWorldService est un plugin et se rend disponible pour un contrat particulier. Comme expliqué en introduction, cela se fait avec l’attribut Export :

[Export(typeof(IHelloWorldService))]
public class HelloWorldService : IHelloWorldService
{
    public string Hello(string who)
    {
        return "Hello " + who;
    }
}

Créons maintenant une classe MefRunner qui va s’occuper d’appeler un plugin respectant le contrat IHelloWorldService.

public class MefRunner
{
    [Import]
    public IHelloWorldService HelloWorldService { get; set; }
  
    public void Run()
    {
        Compose();
        Console.WriteLine(HelloWorldService.Hello("Nico"));
    }
  
    private void Compose()
    {
        string currentDirectory = new FileInfo(Assembly.GetCallingAssembly().Location).Directory.ToString();
        AggregateCatalog catalog = new AggregateCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()), new DirectoryCatalog(currentDirectory));
        var container = new CompositionContainer(catalog);
        container.ComposeParts(this);
    }
}

On voit ici qu’on déclare une propriété de type IHelloWorldService, décorée de l’attribut Import. Cela nous permet de demander à MEF de se débrouiller pour nous fournir quelque chose qui respecte le contrat de la propriété.

Il nous faut maintenant demander à MEF de s’initialiser et d’utiliser sa capacité de découverte de plug-in pour aller fouiller à un emplacement s’il y a un plugin qui pourrait nous être utile.

Pour ce faire, on va utiliser l’objet AggregateCatalog pour lui indiquer de chercher dans l’assembly courante et dans le répertoire de l’exécutable (ce qu’on trouve dans la méthode Compose).

enfin, le CompositionContainer permet d’initialiser MEF.

On voit dans le code du MefRunner qu’aucune référence n’est faite au projet HelloWorldService.

Cependant, la DLL doit bien sur être présente dans le répertoire que nous avons indiqué à MEF (ici, le répertoire de l’exécutable).

Il ne restera qu’à appeler le MefRunner :

public class Program
{
    public static void Main(string[] args)
    {
        MefRunner mefRunner = new MefRunner();
        mefRunner.Run();
    }
}

Notez que MEF n’est pas un IOC, comme Unity. Mais il se sert des techniques d’inversions de contrôles pour son système de plugin.

On peut considérer qu’un IOC est approprié quand il s’agit de charger des dépendances connues à l’avance, alors que MEF est plutôt adapté à la découverte de dépendances inconnues.

Identifiez-vous

Créer un compte

Blog de Nico-pyright(c)

Laisser un commentaire

Articles récents

Commentaires récents

Archives

Catégories

Méta

Identifiant
Mot de passe

Mot de passe oublié ?