Since we didn't need those features, MEF seemed like a good choice. But as it turns out, there is a more subtle problem when using MEF as a general purpose dependency injection container. Consider the following example:
public class Program
{
static void Main(string[] args)
{
var container = new CompositionContainer(
new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var a = container.GetExportedValue<A>();
}
}
[Export]
public class A
{
private readonly B b;
[ImportingConstructor]
public A(B b)
{
this.b = b;
}
}
[Export]
public class B
{
private readonly C c;
[ImportingConstructor]
public B(C c)
{
this.c = c;
}
}
public class C
{
}
The export attribute is missing on the C class in my example. Since class A indirectly depends on class C, we get an error when we try to get an A instance from the container:
System.ComponentModel.Composition.ImportCardinalityMismatchException was unhandled
Message=No valid exports were found that match the constraint '((exportDefinition.ContractName == "DITest.A") AndAlso (exportDefinition.Metadata.ContainsKey("ExportTypeIdentity") AndAlso "DITest.A".Equals(exportDefinition.Metadata.get_Item("ExportTypeIdentity"))))', invalid exports may have been rejected.
Source=System.ComponentModel.Composition
StackTrace: ...
Useful as it may be, stable composition comes at a price. Since MEF can't tell the difference between critical and non-critical parts, the missing dependency error may cascade upward until you get a mysterious ImportCardinalityMismatchException like the one above.
The MEF documentation on Diagnosing Composition Problems acknowledges this and provides some hints on how to debug such problems. Still, for large compositions the process is far from pleasant. Things are even worse if you have some circular dependencies.
Perhaps it would be better to use Autofac to do the core application composition. It doesn't attempt dynamic discovery or stable composition, so the error messages point straight at the missing dependencies. And with the MEF integration, you can still use MEF for the parts of the application where you do need dynamic discovery and stable composition.
