Introduction to MEF



What is MEF?

MEF stands for Managed Extensible Framework. It is part of .Net 4.0 and is useful for building extensible applications. It can be used to plug-in components to already existing application. It is useful as it decouples the components and also it has mechanism to discover components and thus avoid dependencies. MEF enables developers to create extensions dynamically, without the extending application or the extension requiring any specific knowledge of the other.

Basic of MEF :

  • Composition : This is the process of assembling of several different objects into one.
  • ComposableParts : The key building blocks of MEF. ComposableParts enable applications to expose and consume component extensions via Exports and Imports.
  • Contracts : The avenue for communication between Export and Import components. A Contractis normally implemented via an Interface class.
  • Import and Export : Import and Export attributes can be thought of in the same aspect as a supplier and consumer respectively. Export components supply some value; Import components consume that value.
  • ImportMany : It loads all the components that match the given contract as a collection.
  • Composition Container - Core of MEF. In order to discover the parts available to it, the composition containers makes use of a catalog
  • Catalog : A catalog is an object that makes available parts discovered from some source. MEF provides catalogs to discover parts from a provided type, an assembly, or a directory.

Different types of Catalog are :
  • Assembly Catalog: Discovers the different parts on a specific assembly.
  • Directory Catalog: Discovers parts inside the assemblies on a specific directory.
  • Aggregate Catalog: Allows use more than one catalog combining them.
  • Type Catalog: Looks inside the assemblies for specific types.

Why MEF :
  • Loosely coupled architecture - no need to add dependencies but you can directly use Composition using interfaces for mapping Exports and Imports
  • Provides a way for building pluggable components which can be discovered at runtime and so need to recompilation
  • MEF allows tagging extensions with additonal metadata which facilitates rich querying and filtering

How to start with MEF :
  • Create any .Net project and reference to "System.ComponentModel.Composition" assembly.
  • Add the following namespaces to your class

    System.ComponentModel.Composition.Hosting
    System.ComponentModel.Composition
     
  • Define an interface which will be used for compostion.
  • Declare import and export attributes for the properties or methods of the classes participating in composition. For the composition to happen, imports should match the exports. You can use ImportMany when you want to import more than property or method.
  • You need to declare a catalog to be used (it can be assembly or directory or combination of both – using aggregate catalog, etc)
  • Then the Composition Container will hold the catalog and search within the catalog for satisfying the composition when we use ComposeParts method.

I have tried to explain at a very basic level. You can download the source code also and go through the sample.

I will try to come up with some more complex scenario / example on MEF. There are lot of areas where we can use MEF particularly for extensibility and discovering components at runtime.

In short, MEF tries to compose parts in such a way that the imports match the exports.

Where is MEF available :

It is available as part of .Net 4.0 as well as it is available in Codeplex.

This is just an introduction to MEF, basic terminologies used and how it is useful. I will come up with a follow up article which has some samples very soon.