插件式桌面应用开发选型：MEF是否仍适用？求WinForm替代方案

Hey there! Let's break down your questions one by one since you're aiming to build a plugin-based WinForms app with an Eclipse-style architecture—super cool goal, by the way.

Here's the deal: MEF (Managed Extensibility Framework) was Microsoft's first official solution for plugin-based .NET apps, launched way back with .NET 4.0. But as .NET evolved into .NET Core and later .NET 5+, Microsoft shifted its focus to built-in dependency injection (DI) as the standard for modular and extensible code.

MEF never got a full overhaul for modern .NET—it was stuck in the old .NET Framework world. Its API felt clunky compared to modern DI: attributes like [Export] and [Import] made code tightly coupled to MEF, configuration was verbose, and it lacked modern features like async support or robust type safety.

On top of that, since Microsoft started pushing its built-in DI as the default, the community gradually moved away from MEF. Documentation stagnated, bug fixes stopped, and new projects rarely chose it over lighter, more integrated alternatives. That's why you're seeing it fade into obscurity.

Short answer: Probably not for a new project.

If you were maintaining an existing app that already uses MEF, it makes sense to stick with it. But for a fresh plugin-based WinForms app, MEF's downsides will hurt you long-term:

• No official support for modern .NET (you'd be stuck on .NET Framework if you rely on MEF's full feature set)
• Limited community help when you hit issues
• Clunky integration with modern .NET features like DI, async, or trimming

You'd be better off with a solution that's actively maintained and fits into the current .NET ecosystem.

Since you're a WinForms pro and not familiar with WPF, here are the best options tailored to your stack:

.NET Built-in DI + Custom Plugin Loader #

This is my top recommendation—it's lightweight, uses standard .NET tools, and plays nicely with WinForms. Here's how it works:

1. Define a shared interface (e.g., IPlugin) that all plugins must implement, with methods like Initialize() or GetUIElements().
2. Create a plugin loader that scans a specified directory for DLLs, uses reflection to find types that implement IPlugin, and instantiates them.
3. Register these plugin instances in the built-in DI container (or inject any required services into them).

Example snippet for loading plugins:

var pluginDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Plugins");
foreach (var dllPath in Directory.GetFiles(pluginDirectory, "*.dll"))
{
    var assembly = Assembly.LoadFrom(dllPath);
    foreach (var type in assembly.GetTypes().Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsAbstract))
    {
        var plugin = (IPlugin)Activator.CreateInstance(type);
        // Register with DI or initialize directly
        plugin.Initialize(mainForm);
    }
}

This gives you full control without tying yourself to a third-party framework.

Prism (WinForms Support) #

Prism is best known for WPF, but it has solid WinForms support too. Its modular system is designed exactly for Eclipse-style plugin architectures:

• You can package plugins as "modules" with their own views, services, and dependencies.
• Prism handles module discovery, loading (including lazy loading), and integration with DI.
• It has built-in tools for managing UI composition, which is perfect for adding plugin-specific forms or controls to your main WinForms app.

Even if you don't know WPF, Prism's WinForms API is intuitive and aligns with the WinForms patterns you already know.

Autofac with Module Support #

Autofac is a popular third-party DI container with a powerful module system. You can package each plugin as an Autofac module, which registers the plugin's services and components. Then your main app can dynamically load these modules from DLLs and add them to the Autofac container.

Autofac's documentation is excellent, and it's actively maintained. It's a great choice if you want more advanced DI features than the built-in .NET container offers.

Mono.Addins #

Mono.Addins is a cross-platform plugin framework that works seamlessly with WinForms. It handles all the heavy lifting:

• Plugin registration and discovery
• Dependency management between plugins
• Versioning and update support

It has a simple API, and since it's cross-platform, you could even port your app to .NET 6+ later without rewriting the plugin system.

内容的提问来源于stack exchange，提问作者Tu Tran