This article explains the problems with MEF1 and improvements in MEF2 (in .NET 4.5). Attached is a Visual Studio solution built in .NET 4.5.
Read the following articles for more on MEF:
The primary focus of MEF1 was extensibility, MEF allows to create an application such that application's different parts can be extended like a plug-in.
MEF1 has some problems...
- There was no way exporting types without giving them export attribute. This limitation has two consequences:
- It was not possible to export types that you do not have access to the source code
- While converting one existing application into an extensible MEF application, first all types need to be decorated with export attribute
- Control lifetime of an instance, as MEF1 has only two instance scopes:
- per instance and
- shared global lifetime
- Composition problems were not easy to diagnose.
MEF2 has solved the above problems:
- Attribute-less registration: One new class
RegistrationBuilder is introduced that handles part creation and export registration automatically, it has solved both problems arising because the export attribute is required for type registration.
RegistrationBuilder introduced three
For*() methods as below that can identify/select parts to export.
ForType(): selects a single type. In the code below, you can see how the type
AnniversaryGreetings is exported and imported.
var anniGreeting = container.GetExportedValue<AnniversaryGreetings>();
ForTypesDerivedFrom(): selects types that are assignable to either a base class or an interface (the same as
InheritedExport in MEF1) . In the code below, you can see how all types derived from
IGreetings are exported and imported.
.SelectConstructor(cInfo => cInfo) .Export<IGreetings>();
var v = container.GetExportedValues<IGreetings>();
ForTypesMatching(Predicate predicate): selects types that match a Boolean selector. This is the most flexible means of selection. In the code below, you can see how the type name matching "
Greetings" is exported and imported:
regisBuilder.ForTypesMatching(x => x.Name.Equals("HomeGreetings")).Export();
var greetings = container.GetExportedValue<HomeGreetings>();
- Finer-Grained Control Over Lifetime
ExportFactory improves granularity by allowing developers to create new instances of dependencies and control the lifetimes of the parts.
ExportFactory<t> can be exported which actually exports the type
T, but it doesn’t create instance. Instance of the type will get created when it is accessed with method
The return value of
ExportCreator<t>.CreateExport() is a
ExportLifetimeContext<t> has a property called value that contains instance of the type
ExportLifetimeContext<t> also provides implementation of
iDisposable, so instance can be cleaned when it is not required. In the code below, you can see how the
ExportFactory<t> is used to export the type and create instance by calling
public class ExportFactoryExample
public ExportFactoryExample(ExportFactory<Greetings> factory)
_factory = factory;
public string Greeting(string name)
using (var instance = _factory.CreateExport())
var exportType = container.GetExportedValue<ExportFactoryExample>();
ExportFactory v/s Lazy objects: The difference between
ExportFactory and a
Lazy object is that with the
Lazy class, you can only create a single instance of the object. The
ExportFactory is a class that allows you to request a new instance of the type of object whenever you feel like it.
- Diagnostics improvements: Two major improvements have been made to diagnostics.