2.5. MEF

Managed Extensibility Framework (MEF) is a new framework for creating customizable applications that can be used by any .NET-compatible language. Glenn Block (PM for the new MEF in .NET 4.0) says the following:

Quite simply, MEF makes building extensible apps, libraries, and frameworks easy. It shares some common characteristics of other frameworks out there, but it also addresses a whole new set of problems that arise in building extremely large scalable extensible systems.

http://blogs.msdn.com/gblock/archive/2008/09/26/what-is-the-managed-extensibility-framework.aspx

Let's say you have created a Tetris application and want to allow users to extend it by creating their own shapes of bricks. MEF enables you to do this by defining a brick interface and then dynamically loading and resolving the created extensions.

When creating a MEF application, take the following steps:

2.5.1. Why Use MEF?

Using MEF has the following advantages:

• Microsoft hopes that MEF will become the preferred standard method of creating extensions. By utilizing a standard plug-in model, your extensions could be used in many applications.

• MEF provides a number of flexible ways to load your extensions.

• Extensions can contain metadata to provide further information about their capabilities. For example, you may only want to load extensions that can communicate securely.

• MEF is open source and works on VS2008 (www.codeplex.com/MEF).

2.5.2. Hello MEF

In this sample application, you will create two extensions that print out a message. You will then load them both into an IEnumerable<string> variable called Message before iterating through them and printing out the messages.

Congratulations, you have created your first MEF application.

2.5.3. How Did This Example Work?

You started off by telling MEF that your Message property can be extended by marking it with the [Import] attribute. The [Import] attribute means "I can be extended" to MEF:

[Import]
public string Message { get; set; }

You then created an extension class and added the [Export] attribute. [Export] tells MEF "I am an extension":

class extension1
{
    [Export]
    public string Message
    {
        get
        {
            return "I am extension 1";
        }
    }
}

You then created a container (containers resolve MEF extensions when they are requested) to hold the extensions and added your extension classes to it using a CompositionBatch:

CompositionContainer container = new CompositionContainer();
CompositionBatch batch = new CompositionBatch();
batch.AddPart(new extension1());
batch.AddPart(this);

The Compose() method was then called, which caused MEF to load our extensions into the Message property:

container.Compose(batch);

MEF then loaded extensions into the Messages property decorated with the [Export] attribute that matched the contract. Finally, you printed out the message to the screen. In this example, you only loaded extensions contained within the project itself, which isn't too useful. Luckily MEF allows you to load extensions declared outside the project.

2.5.4. MEF Catalogs

MEF uses a concept called catalogs to contain extensions. Catalogs come in three different flavors:

• Assembly: Extensions are contained in a .NET assembly.

• Directory: Extensions are in a physical directory.

• Aggregate: This is a catalog type that contains both assembly and directory extensions.

In this example you will use a directory catalog to load an extension defined outside the main project. Directory catalogs scan the target directory for compatible extensions when first created. You can rescan the directory by calling the Refresh() method.

2.5.5. Metadata

An important feature of MEF is that you can provide additional information about an extension's capabilities with metadata. MEF can then utilize this information to determine the most appropriate extension to load and query its capabilities. For example, in the previous logging example, you might specify whether the logging method is secure, and then in high-security environments only load extensions that communicated securely. Metadata can be defined at a class or method level.

To add metadata to a class, use the [PartMetaData] attribute:

[PartMetadata("secure", "false")]
[Export(typeof(Chapter2.MEFInterfaces.ILogger))]
public class EmailLogger : MEFInterfaces.ILogger
{..}

You can add metadata to an individual method with the [ExportMetadata] attribute:

[ExportMetadata("timeout", "5000")]
public string WriteToLog(string Message)
{..}

Metadata can then be retrieved using a part's Metadata property. The following code demonstrates retrieving metadata from a directory catalog:

CompositionContainer container;
DirectoryCatalog directoryCatalog =
  New DirectoryCatalog((Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)));

foreach (var Part in directoryCatalog.Parts)
{
    Console.WriteLine(Part.Metadata["secure"]);
}

Note that querying a method's metadata is slightly different and that you must instead use the Part.ExportDefinitions property.

2.5.6. What's This All Got to Do with Visual Studio Extensibility?

Visual Studio utilizes MEF in an almost identical way to the previous examples when it loads Visual Studio extensions. When Visual Studio first loads, it examines the extensions directory and loads available extensions. Let's now look into how these extensions are created.