Extending the Enterprise Extending the Enterprise with MEF with MEF Brian Ritchie Chief Architect PaySpan, Inc. Twitter: @brian_ritchie Email: [email protected]Blog: http://weblog.asp.net/britchie Web: http://www.dotnetpowered.com Building extensibility into your enterprise apps with the Managed Extensibility Framework Jason Gerard Director of Product Development PaySpan, Inc. Twitter: @thejasongerard Email: [email protected]Blog: http://jasongerard.wordpress.com
Transcript
Extending the Enterprise Extending the Enterprise with MEFwith MEF
Agenda»What is MEF?»When to use MEF»Benefits of using MEF»Key Concepts»What’s new in .NET 4.5?»Demo!
What is MEF?What is MEF?
The Managed Extensibility Framework or MEF is a library for creating lightweight, extensible applications.
»It allows application developers to discover and use extensions with no configuration required. It lets extension developers easily encapsulate code and avoid fragile hard dependencies. MEF not only allows extensions to be reused within applications, but across applications as well.
When to use MEF?When to use MEF?
And when not to...And when not to...
When to use MEF?When to use MEF?
» You are planning to star in a zombie movie» You weren’t born in Britain but want British
teeth.NO!
We’re talking about MEF not METH!!
When to use MEF?When to use MEF?
» Only if you are building an extensible UI with Silverlight or WPF applications
NO!
Building extensible applications is one of the key nonfunctional requirements in enterprise application development scenarios.
.NET 4 for Enterprise Architects and Developers
When to use MEF?When to use MEF?
» When you need a general purpose Dependency Injection framework or an Inversion of Control Container
NO!
We are not aiming for MEF to be an all-purpose IoC. The best way to think about the IoC aspects of MEF is an implementation detail. We use IoC as a pattern because it is a great way to address the problems we are looking to solve.
Glenn BlockMicrosoft
When to use MEF?When to use MEF?
» MEF is especially useful for large applications where injecting the dependencies between distant parts would get hard to manage as the size of the code base increases.
MEF is focused on extensibility. When you think of MEF look at it as an investment in taking our platform forward. Our future products and the platform will leverage MEF as a standard mechanism for adding extensibility.
Imagine when you want to extend our platform in the future, you drop a DLL in the bin folder and you are done. The MEF enabled app lights up with the new extension. That's the vision for MEF.
Glenn BlockMicrosoft
YES!
Benefits of being a MEF userBenefits of being a MEF user
» Decomposes large systems into building
blocks
» Allows extensibility across teams
» Turns your app into a platform
Ready to get hooked Ready to get hooked on MEF?on MEF?
MEF Key ConceptsMEF Key Concepts
MEF Key ConceptsMEF Key Concepts
Exports & Imports»Exports expose contracts for functionality that can be replaced at runtime. Exports are defined in your plugin libraries.»Imports are properties that consume Exported instances. Imports are defined in your host application.
MEF Key ConceptsMEF Key Concepts
» ExportsDecorating a class with the Export attribute
The interface (IPlugin) should be in Contract Assembly that can be shared between the importer (host application) and the exporter
(plugin).
[Export(typeof(IPlugin)]public class MyPlugin : IPlugin{
}
[Export(typeof(IPlugin)]public class MyPlugin : IPlugin{
}
MEF Key ConceptsMEF Key Concepts
» ImportsDecorating the host class with an ImportMany attribute
public class Host{ [ImportMany(typeof(IPlugin))] public IEnumberable<IPlugin> Plugins { get; set; }
...}
public class Host{ [ImportMany(typeof(IPlugin))] public IEnumberable<IPlugin> Plugins { get; set; }
...}
The interface (IPlugin) should be in Contract Assembly that can be shared between the importer (host application) and the exporter
(plugin).
MEF Key ConceptsMEF Key Concepts
» ImportsExports can also define imports. For example, a plugin maybe dependent on a service from the host.
[Export(typeof(IPlugin)]public class MyPlugin : IPlugin{[Import]IService Dependency { get; set; }
}
[Export(typeof(IPlugin)]public class MyPlugin : IPlugin{[Import]IService Dependency { get; set; }
}
MEF Key ConceptsMEF Key Concepts
Composition»Composition binds the Export with an Import at runtime to deliver the functionality.»A Catalog hosts the exports that need to be composed.»Types of catalogs:
» Assembly Catalog
» Directory Catalog
» Aggregate Catalog
» Type Catalog
MEF Key ConceptsMEF Key Concepts
Composition»Loading a catalog and binding the exports to the imports:
var catalog = new DirectoryCatalog(@".\plugins");
var container = new CompositionContainer(catalog);
container.ComposeParts(host);
var catalog = new DirectoryCatalog(@".\plugins");
var container = new CompositionContainer(catalog);
container.ComposeParts(host);
MEF Key ConceptsMEF Key Concepts
Composition»The Plugins collection now contains instances of all the exported types.
public class Host{ [ImportMany(typeof(IPlugin))] public IEnumberable<IPlugin> Plugins { get; set; }
...}
public class Host{ [ImportMany(typeof(IPlugin))] public IEnumberable<IPlugin> Plugins { get; set; }
...}
MEF Key ConceptsMEF Key Concepts
Metadata»Custom metadata can be attached to your exported types to provide information to the importer.»Simply add an ExportMetadata attribute which accepts a key and a value:
[ExportMetadata(“ID”, 1)][Export(typeof(IPlugin)]public class MyPlugin : IPlugin{
}
[ExportMetadata(“ID”, 1)][Export(typeof(IPlugin)]public class MyPlugin : IPlugin{
}
MEF Key ConceptsMEF Key Concepts
Metadata»In the importer, define an Interface to access the metadata. The property and data type must match the name/value pair specified in the ExportMetadata attribute.
public interface PluginMetadata{ int ID { get;set;}}
public interface PluginMetadata{ int ID { get;set;}}
MEF Key ConceptsMEF Key Concepts
Metadata»Next, define the import to also load the metadata. Access both via .NET lazy load class.
public class Host{ [ImportMany] public IEnumerable<Lazy<IPlugin, IPluginMetadata>> Plugins { get; set; }
void UsePlugins() { foreach (var p in Plugins) { var id = p.Metadata.ID; var plugin = p.Value; } }}
public class Host{ [ImportMany] public IEnumerable<Lazy<IPlugin, IPluginMetadata>> Plugins { get; set; }
void UsePlugins() { foreach (var p in Plugins) { var id = p.Metadata.ID; var plugin = p.Value; } }}
What’s new in .NET 4.5?What’s new in .NET 4.5?
» Support for generic types» Multiple scopes » Convention-based programming model that
enables you to create parts based on rules rather than attributes.
// Instead of using Export() attribute on Loggervar registration = new RegistrationBuilder();registration.ForType<Logger>().Export<ILogger>();
// Apply to all classes derived from ILoggerregistration.ForTypesDerivedFrom<ILogger>().Export<ILogger>();
// Instead of using Export() attribute on Loggervar registration = new RegistrationBuilder();registration.ForType<Logger>().Export<ILogger>();
// Apply to all classes derived from ILoggerregistration.ForTypesDerivedFrom<ILogger>().Export<ILogger>();
Give me some MEF!Give me some MEF!
Demo!Demo!
https://github.com/jasongerard/MefExample
Extending the Enterprise with MEFExtending the Enterprise with MEF
