Dot.Blog

Est-il possible de créer une architecture plugin en .NET pour étendre dynamiquement son application mais de façon très simple en quelques lignes de code ? Oui c'est possible !

🎯 Objectif

Concevoir une application .NET (desktop, CLI ou service) capable de charger dynamiquement des plugins sans recompilation. Cela permet :

• D’ajouter des fonctionnalités sans toucher au cœur
• De séparer les responsabilités (modules fonctionnels)
• De distribuer des extensions à part

🧱 Concepts clés

🧩 Étape 1 – Définir un contrat commun

Dans un projet partagé (MonApp.Abstractions) :

public interface IPlugin
{
    string Name { get; }
    string Execute(string input);
}

L’application principale et les plugins référencent ce projet.

📦 Étape 2 – Implémenter un plugin

public class ReversePlugin : IPlugin
{
    public string Name => "Inverseur de texte";

    public string Execute(string input)
    {
        return new string(input.Reverse().ToArray());
    }
}

Compilez ce plugin en .dll (ex. ReversePlugin.dll) dans un dossier Plugins/.

🔍 Étape 3 – Charger dynamiquement les plugins

var plugins = new List<IPlugin>();
var files = Directory.GetFiles("Plugins", "*.dll");

foreach (var file in files)
{
    var asm = Assembly.LoadFrom(file);
    var types = asm.GetTypes().Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsInterface);

    foreach (var type in types)
    {
        if (Activator.CreateInstance(type) is IPlugin plugin)
        {
            plugins.Add(plugin);
        }
    }
}

🖥️ Exemple d’usage depuis une app WinForms / WPF

foreach (var plugin in plugins)
{
    Console.WriteLine($"{plugin.Name} → {plugin.Execute("Bonjour")}");
}

⚙️ Astuces avancées

• Utilisez AssemblyLoadContext pour isoler les dépendances entre plugins.
• Générez un fichier plugin.json par plugin pour embarquer des métadonnées.
• Intégrez une interface graphique pour activer/désactiver les plugins.

✅ Avantages

🧠 Cas d’usage

• Outil métier personnalisable selon client
• App IA avec moteurs interchangeables
• UI desktop modulaire (analyseurs, exportateurs, traitements, etc.)

Conclusion

Avec une architecture plugin bien conçue, votre application .NET devient modulaire, extensible et maintenable à long terme. C’est un excellent pattern pour les outils professionnels, même sans cloud ni infrastructure distante.