CSS：如何有位置：一个位置的绝对div：相对div不被一个溢出：被隐藏在一个容器上(CSS: How to have position:absolute div inside a position:relative div not be cropped by an overflow:hidden on a container)

 主要区别在于统一性，您将明确地注册要在组合中使用的每个类： 
 
var container = new UnityContainer();
container.RegisterType<IFoo,Foo>();
container.RegisterType<IBar,Bar>();
...
var program = container.Resolve<Program>();
program.Run();
 
 另一方面，在MEF中，您可以使用属性标记类，而不是在其他地方注册它们： 
 
[Export(typeof(IFoo))]
public Foo
{
   ...
}
 
 一见钟情就像一个小小的句法差异，但实际上比这更重要。 MEF旨在允许动态发现零件。 例如，使用DirectoryCatalog ，您可以通过简单地将应用程序文件夹中的新DLL拖放到扩展方案中来设计应用程序。 
 
 在本示例中，MEF将在给定目录中使用[Export(typeof(IPlugin))]属性查找并实例化所有类，并将这些实例传递给Program构造函数： 
 
[Export]
public class Program
{
    private readonly IEnumerable<IPlugin> plugins;

    [ImportingConstructor]
    public Program(
       [ImportMany(typeof(IPlugin))] IEnumerable<IPlugin> plugins)
    {
        this.plugins = plugins;
    }

    public void Run()
    {
        // ...
    }
}
 
 入口点： 
 
public static void Main()
{
    using (var catalog = new DirectoryCatalog(".","*"))
    using (var container = new CompositionContainer(catalog))
    {
        var program = container.GetExportedValue<Program>();
        program.Run();
    }
}
 
 为了适应这种动态组合情景，MEF具有“稳定组合”的概念，这意味着当它在某处遇到缺失依赖时，它将简单地将该部分标记为不可用，并且将继续组合。 
 
 稳定的组合可能是非常有用的 ，但它也使得很难调试失败的组合 。 因此，如果您不需要动态发现零件和“稳定组合”，我将使用常规DI容器而不是MEF。 与MEF不同，常规DI容器会在缺少依赖关系时给出明确的错误消息。 
 
 也可以通过使用与MEF集成的DI容器（如Autofac）来获得两个世界的最佳效果 。 使用Autofac构建核心应用程序，MEF可用于需要动态扩展的部件。 

The main difference is that with unity you will explicitly register each class you want to use in the composition:
 
var container = new UnityContainer();
container.RegisterType<IFoo,Foo>();
container.RegisterType<IBar,Bar>();
...
var program = container.Resolve<Program>();
program.Run();
 
In MEF on the other hand, you mark classes with attributes instead of registering them somewhere else:
 
[Export(typeof(IFoo))]
public Foo
{
   ...
}
 
At first sight this looks like a minor syntactic difference, but it is actually more important than that. MEF is designed to allow for the dynamic discovery of parts. For example, with a DirectoryCatalog you can design your application in such a way that you can extend it by simply dropping new DLLs in the application folder. 
 
In this example, MEF will find and instantiate all classes with an [Export(typeof(IPlugin))] attribute in the given directory and passes those instances to the Program constructor:
 
[Export]
public class Program
{
    private readonly IEnumerable<IPlugin> plugins;

    [ImportingConstructor]
    public Program(
       [ImportMany(typeof(IPlugin))] IEnumerable<IPlugin> plugins)
    {
        this.plugins = plugins;
    }

    public void Run()
    {
        // ...
    }
}
 
Entry point:
 
public static void Main()
{
    using (var catalog = new DirectoryCatalog(".","*"))
    using (var container = new CompositionContainer(catalog))
    {
        var program = container.GetExportedValue<Program>();
        program.Run();
    }
}
 
To accommodate such dynamic composition scenarios, MEF has a concept of "stable composition", which means that when it runs into a missing dependency somewhere it will simply mark the part as unavailable and will continue the composition anyway. 
 
Stable composition can be quite useful, but it also makes it very difficult to debug a failed composition. So if you don't need dynamic discovery of parts and "stable composition", I would use a regular DI container instead of MEF. Unlike MEF, regular DI containers will give you clear error messages when a dependency is missing.
 
It might also be possible to get the best of both worlds by using a DI container which integrates with MEF, like Autofac. Use Autofac to compose the core application, and MEF for the parts which need to be dynamically extensible.