MEF Wiki & Documentation Rss Feed

New Comment on "Exports and Metadata"

kfitzie — Wed, 04 Nov 2009 18:45:09 GMT

Why can't I have IEnumerable<IMessageSender, IMessageSenderCapabilities> ?

New Comment on "Architecture"

aL3891 — Wed, 28 Oct 2009 10:28:53 GMT

a total nitpick, but in the white paper you define a class square, but the number of sides property returns 5, i assume you mean 4 :)

Updated Wiki: Exports and Metadata

weshaggard — Tue, 27 Oct 2009 23:03:49 GMT

Exports and Metadata

Declaring Exports explained the basics of parts exporting services and values. In some cases it’s necessary to associate information with exports for a variety of reasons. Commonly it’s used to explain about the capabilities of an specific implementation of a common contract. This is useful to allow imports to either constraint the export that can satisfy it, or to import all available implementations at the time and check their capabilities in runtime before using the export.

Attaching Metadata to an Export

Consider the IMessageSender service introduced earlier. Suppose we have a few implementations, and they have differences that may be relevant to the consumer of the implementations. For our example the transport of the message and whether is secure are important information for a consumer (importer).

Using ExportMetadataAttribute

All we have to do to attach this information is to use the [System.ComponentModel.Composition.ExportMetadataAttribute]:

public interface IMessageSender
{
    void Send(string message);
}

[Export(typeof(IMessageSender))]
[ExportMetadata("transport", "smtp")]
public class EmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[Export(typeof(IMessageSender))]
[ExportMetadata("transport", "smtp")]
[ExportMetadata("secure", null)]
public class SecureEmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[Export(typeof(IMessageSender))]
[ExportMetadata("transport", "phone_network")]
public class SMSSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

Using a Custom Export Attribute

In order to do it more strongly typed than using the ExportMetadataAttribute, you need to create your own attribute and decorate it with [System.ComponentModel.Composition.MetadataAttribute]. In this example we also derive from ExportAttribute, thus creating a custom Export attribute that also specifies metadata.

[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class, AllowMultiple=false)]
public class MessageSenderAttribute : ExportAttribute
{
    public MessageSenderAttribute() : base(typeof(IMessageSender)) { }
    public MessageTransport Transport { get; set; }
    public bool IsSecure { get; set; }
}

public enum MessageTransport
{
    Undefined,
    Smtp,
    PhoneNetwork,
    Other
}

Above, the MetadataAttribute is applied to our custom export attribute. The next step is to apply the attribute to our IMessageSender implementations:

[MessageSender(Transport=MessageTransport.Smtp)]
public class EmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[MessageSender(Transport=MessageTransport.Smtp, IsSecure=true)]
public class SecureEmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[MessageSender(Transport=MessageTransport.PhoneNetwork)]
public class SMSSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

That’s all that is required on the export side. Under the hood, MEF is still populating a dictionary, but this fact becomes invisible to you.

Note: You can also create metadata attributes that are not themselves exports, by creating an attribute which is decorated with MetadataAttributeAttribute. In these cases the metadata will be added to Exports on the same member where the custom metadata attribute was applied.

Importing Metadata

Importers can access the metadata attached to the exports.

Using Strongly-typed Metadata

To access metadata in a strongly-typed fashion created a metadata view by definining an interface with matching read only properties (names and types). For our sample it would be an interface like the following:

public interface IMessageSenderCapabilities
{
    MessageTransport Transport { get; }
    bool IsSecure { get; }
}

Then you can start importing using the type System.Lazy<T, TMetadata> where T is the contract type and TMetadata is the interface you’ve created.

[Export]
public class HttpServerHealthMonitor
{
    [ImportMany]
    public Lazy<IMessageSender, IMessageSenderCapabilities>[] Senders { get; set; }

    public void SendNotification()
    {
        foreach(var sender in Senders)
        {
            if (sender.Metadata.Transport == MessageTransport.Smtp && 
                sender.Metadata.IsSecure)
            {
                var messageSender = sender.Value;
                messageSender.Send("Server is fine");
                
                break;
            }
        }
    }
}

Using Weakly-typed metadata

To access metadata in a weakly-typed fashion, you import uisng the type System.Lazy<T, TMetadata> passing IDictionary<string,object> for the metadata. You can then access the metadata through the Metadata property which will be a dictionary.

Note: In general we recommend the strongly-typed method for accessing metadata, however there are systems that need to access the metadata in a dynamic fashion, which this allows.

[Export]
public class HttpServerHealthMonitor
{
    [ImportMany]
    public Lazy<IMessageSender, IDictionary<string,object>>[] Senders { get; set; }

    public void SendNotification()
    {
        foreach(var sender in Senders)
        {
            if (sender.Metadata.ContainsKey("Transport") && sender.Metadata["Transport"] == MessageTransport.Smtp && 
                sender.Metadata.ContainsKey("Issecure") && Metadata["IsSecure"] == true)
            {
                var messageSender = sender.Value;
                messageSender.Send("Server is fine");
                
                break;
            }
        }
    }
}

Metadata filtering and DefaultValueAttribute

When you specifiy a metadata view, an implicit filtering will occur to match only those exports which contain the metadata properties defined in the view. You can specify on the metadata view that a property is not required, by using the System.ComponentModel.DefaultValueAttribute. Below you can see where we have specified a default value of false on IsSecure. This means if a part exports IMessageSender, but does not supply IsSecure metadata, then it will still be matched.

public interface IMessageSenderCapabilities
{
    MessageTransport Transport { get; }
    [DefaultValue(false)];
    bool IsSecure { get; }
}

Updated Wiki: Exports and Metadata

weshaggard — Tue, 27 Oct 2009 23:01:18 GMT

Exports and Metadata

Attaching Metadata to an Export

Using ExportMetadataAttribute

All we have to do to attach this information is to use the [System.ComponentModel.Composition.ExportMetadataAttribute]:

public interface IMessageSender
{
    void Send(string message);
}

[Export(typeof(IMessageSender))]
[ExportMetadata("transport", "smtp")]
public class EmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[Export(typeof(IMessageSender))]
[ExportMetadata("transport", "smtp")]
[ExportMetadata("secure", null)]
public class SecureEmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[Export(typeof(IMessageSender))]
[ExportMetadata("transport", "phone_network")]
public class SMSSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

Using a Custom Export Attribute

[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class, AllowMultiple=false)]
public class MessageSenderAttribute : ExportAttribute
{
    public MessageSenderAttribute() : base(typeof(IMessageSender)) { }
    public MessageTransport Transport { get; set; }
    public bool IsSecure { get; set; }
}

public enum MessageTransport
{
    Undefined,
    Smtp,
    PhoneNetwork,
    Other
}

Above, the MetadataAttribute is applied to our custom export attribute. The next step is to apply the attribute to our IMessageSender implementations:

[MessageSender(Transport=MessageTransport.Smtp)]
public class EmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[MessageSender(Transport=MessageTransport.Smtp, IsSecure=true)]
public class SecureEmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

[MessageSender(Transport=MessageTransport.PhoneNetwork)]
public class SMSSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine(message);
    }
}

Importing Metadata

Importers can access the metadata attached to the exports.

Using Strongly-typed Metadata

public interface IMessageSenderCapabilities
{
    MessageTransport Transport { get; }
    bool IsSecure { get; }
}

Then you can start importing using the type {[{System.Lazy<T, TMetadata>}}] where T is the contract type and TMetadata is the interface you’ve created.

[Export]
public class HttpServerHealthMonitor
{
    [ImportMany]
    public Lazy<IMessageSender, IMessageSenderCapabilities>[] Senders { get; set; }

    public void SendNotification()
    {
        foreach(var sender in Senders)
        {
            if (sender.Metadata.Transport == MessageTransport.Smtp && 
                sender.Metadata.IsSecure)
            {
                var messageSender = sender.Value;
                messageSender.Send("Server is fine");
                
                break;
            }
        }
    }
}

Using Weakly-typed metadata

To access metadata in a weakly-typed fashion, you import uisng the type {{System.Lazy<T, TMetadata>}} passing IDictionary<string,object> for the metadata. You can then access the metadata through the Metadata property which will be a dictionary.

Note: In general we recommend the strongly-typed method for accessing metadata, however there are systems that need to access the metadata in a dynamic fashion, which this allows.

[Export]
public class HttpServerHealthMonitor
{
    [ImportMany]
    public Lazy<IMessageSender, IDictionary<string,object>>[] Senders { get; set; }

    public void SendNotification()
    {
        foreach(var sender in Senders)
        {
            if (sender.Metadata.ContainsKey("Transport") && sender.Metadata["Transport"] == MessageTransport.Smtp && 
                sender.Metadata.ContainsKey("Issecure") && Metadata["IsSecure"] == true)
            {
                var messageSender = sender.Value;
                messageSender.Send("Server is fine");
                
                break;
            }
        }
    }
}

Metadata filtering and DefaultValueAttribute

public interface IMessageSenderCapabilities
{
    MessageTransport Transport { get; }
    [DefaultValue(false)];
    bool IsSecure { get; }
}

Updated Wiki: Composition Batch

weshaggard — Tue, 27 Oct 2009 22:58:30 GMT

Composition Batch

A MEF container instance is not immutable. Changes can happen if the catalog supports changes (like watching a directory for changes) or if your code add or remove parts in runtime. Previously you had to make the changes and invoke the Compose method on the CompositionContainer. In the Preview 4 release we have introduced support for a composition batch.

The batch contains a list of parts to be added and/or removed. After performing the changes, the container automatically triggers a composition which updates recomposable imports affected by the changes.
As a scenario, consider a settings window and a user selecting and deselecting options. Those would map to parts present or not on the container. To apply the batch, you would call the Compose method, as follows:

var batch = new CompositionBatch();
batch.AddPart(partInstance1);
batch.AddPart(partInstance2);
batch.RemovePart(part3);

container.Compose(batch);

For types that actually use the attributed programming model there are some extension methods on AttributedModelServices for CompositionContainer that allow you to do hide the CompositionBatch in some common cases where it isn't needed.

container.ComposeParts(partInstance1, partInstance2,... ); // creates a CompositionBatch and calls AddPart on all the passed parts followed by Compose
container.ComposeExportedValue<IFoo>(instanceOfIFoo); // creates a CompositionBatch and calls AddExportedValue<T> followed by Compose.

Updated Wiki: Parts

weshaggard — Tue, 27 Oct 2009 22:50:59 GMT

Defining Composable Parts and Contracts

Composable Parts

A Composable Part is a composable unit within MEF. Composable Parts export services that other Composable Parts need, and import services from other Composable Parts. In the MEF programming model, Composable Parts are attributed with the System.ComponentModel.Composition.Import and [System.ComponentModel.Composition.Export] attribute in order to declare their exports and imports. A Composable Part should contain at least one export. Composable Parts are either added to the container explicity or created through the use of catalogs. The default catalogs that MEF ship with identify Composable Parts through the presence of an export attribute.

Contracts

Composable Parts do not directly depend on one another, instead they depend on a contract, which is a string identifier. Every export has a contract, and every import declares the contract it needs. The container uses the contract information to match up imports to exports. If no contract is specified, MEF will implicitly use the fully qualified name of the type as the contract. If a type is passed, it will also use the fully qualified name.

Note: By default a type should be passed for a contract, and not a string. Although contracts can be an arbitrary string this can lead to ambiguity. For example "Sender" might overlap with another implementation of "Sender" in a different library. For this reason if you do need to specify a string constract, it is recommend that contract names should be qualified with a namespace that includes the Company Name for example "Contoso.Exports.Sender".

In the code snippet below, all export contracts are equivalent.

namespace MEFSample 
{
  [Export]
  public class Exporter {...}

  [Export(typeof(Exporter))]
  public class Exporter1 {...}

  [Export("MEFSample.Exporter")]
  public class Exporter2 {...}
}

Interface / Abstract contracts

A common pattern is for a Composable Part to export an interface or an abstract type contract rather than a concrete type. This allows the importer to be completely decoupled from the specific implementation of the export it is importing resulting in a separation of concerns. For example below you can see there are two sender implementations that both export IMessageSender. The Notifier class imports a collection of IMessageSender which it invokes in its Send() method. New message senders can now easily be added to the system.

  [Export(typeof(IMessageSender))]
  public class EmailSender : IMessageSender {
    ...
  }

  [Export(typeof(IMessageSender))]  
  public class TCPSender : IMessageSender {
    ...
  }

  public class Notifier {
    [ImportMany]
    public IEnumerable<IMessageSender> Senders {get; set;}
    public void Notify(string message) {
      foreach(IMessageSender sender in Senders) 
        sender.Send(message);
    } 
  }

Note: You must specify the specific interface type (IMessageSender) being exported otherwise the type (EmailSender) itself will be exported.

New Comment on "Filtering Catalogs"

weshaggard — Tue, 27 Oct 2009 22:08:23 GMT

I've updated the FilteredCatalog to reflect the current (preview 8) code. Also we don't need to unhook any events in the dispose because we aren't explicitly hooking the change event any longer.

Updated Wiki: Filtering Catalogs

weshaggard — Tue, 27 Oct 2009 22:06:18 GMT

Filtering Catalogs

When using child containers it may be important to filter catalogs based on some specific criteria. For example, it is common to filter based on part's creation policy. The following code snippet demonstrates how to set up this particular approach:

var catalog = new AssemblyCatalog(typeof(Program).Assembly);
var parent = new CompositionContainer(catalog);

var filteredCat = new FilteredCatalog(catalog,
    def => def.Metadata.ContainsKey(CompositionConstants.PartCreationPolicyMetadataName) &&
    ((CreationPolicy)def.Metadata[CompositionConstants.PartCreationPolicyMetadataName]) == CreationPolicy.NonShared);
var child = new CompositionContainer(filteredCat, parent);

var root = child.GetExportedObject<Root>();
child.Dispose();

If CreationPolicy is not enough as a criteria to select parts you may want to use the [System.ComponentModel.Composition.PartMetadataAttribute] instead. It allows you to attach metadata to the part so you can use it to construct a filtering expression. For example, the following is a class that with the attribute applied:

[PartMetadata("scope", "webrequest"), Export]
public class HomeController : Controller
{
}

This allows you to create a child container with parts that should be scoped to a (logical) web request. Note that it is up to you to define a scope boundary, in other words, MEF doesn't know what a "webrequest" is, so you have to create some infrastructure code to create/dispose containers per web request.

var catalog = new AssemblyCatalog(typeof(Program).Assembly);
var parent = new CompositionContainer(catalog);

var filteredCat = new FilteredCatalog(catalog,
    def => def.Metadata.ContainsKey("scope") &&
    def.Metadata["scope"].ToString() == "webrequest");
var perRequest = new CompositionContainer(filteredCat, parent);

var controller = perRequest.GetExportedObject<HomeController>();
perRequest.Dispose();

Note that we do not provide a FilteredCatalog class. A simple implementation that illustrates what would take to build one follows:

using System;
using System.ComponentModel.Composition.Primitives;
using System.ComponentModel.Composition.Hosting;
using System.Linq;
using System.Linq.Expressions;

public class FilteredCatalog : ComposablePartCatalog, INotifyComposablePartCatalogChanged
{
    private readonly ComposablePartCatalog _inner;
    private readonly INotifyComposablePartCatalogChanged _innerNotifyChange;
    private readonly IQueryable<ComposablePartDefinition> _partsQuery;

    public FilteredCatalog(ComposablePartCatalog inner,
                           Expression<Func<ComposablePartDefinition, bool>> expression)
    {
        _inner = inner;
        _innerNotifyChange = inner as INotifyComposablePartCatalogChanged;
        _partsQuery = inner.Parts.Where(expression);
    }

    public override IQueryable<ComposablePartDefinition> Parts
    {
        get
        {
            return _partsQuery;
        }
    }

    public event EventHandler<ComposablePartCatalogChangeEventArgs> Changed
    {
        add
        {
            if (_innerNotifyChange != null)
                _innerNotifyChange.Changed += value;
        }
        remove
        {
            if (_innerNotifyChange != null)
                _innerNotifyChange.Changed -= value;
        }
    }

    public event EventHandler<ComposablePartCatalogChangeEventArgs> Changing
    {
        add
        {
            if (_innerNotifyChange != null)
                _innerNotifyChange.Changing += value;
        }
        remove
        {
            if (_innerNotifyChange != null)
                _innerNotifyChange.Changing -= value;
        }
    }
}

Updated Wiki: Using Catalogs

weshaggard — Tue, 27 Oct 2009 21:41:58 GMT

Catalogs

One of value propositions of MEF's attributed programming model is the ability to dynamically discover parts via catalogs. Catalogs allow applications to easily consume exports that have self-registered themselves via the Export attribute. Below is a list the catalogs MEF provides out of the box.

Assembly Catalog

To discover all the exports in a given assembly one would use the [System.ComponentModel.Composition.Hosting.AssemblyCatalog].

var catalog = new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly());

Directory Catalog

To discover all the exports in all the assemblies in a directory one would use the [System.ComponentModel.Composition.Hosting.DirectoryCatalog].

var catalog = new DirectoryCatalog("Extensions");

If a relative directory is used it is relative to the base directory of the current AppDomain.

The DirectoryCatalog will do a one-time scan of the directory and will not automatically refresh when there are changes in the directory. However, you can implement your own scanning mechanism, and call Refresh() on the catalog to have it rescan. Once it rescans, recomposition will occur.

var catalog = new DirectoryCatalog("Extensions");
//some scanning logic
catalog.Refresh();

Aggregate Catalog

When AssemblyCatalog and DirectoryCatalog are not enough individually and a combination of catalogs is needed then an application can use an [System.ComponentModel.Composition.Hosting.AggregateCatalog]. An AggregateCatalog combines multiple catalogs into a single catalog. A common pattern is to add the current executing assembly, as well as a directory catalog of third-party extensions. You can pass in a collection of catalogs to the AggregateCatalog constructor or you can add directly to the Catalogs collection i.e. catalog.Catalogs.Add(...)

var catalog = new AggregateCatalog(
  new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly()), 
  new DirectoryCatalog("Extensions"));

Type Catalog

To discover all the exports in a specific set of types one would use a [System.ComponentModel.Composition.Hosting.TypeCatalog].

var catalog = new TypeCatalog(typeof(type1), typeof(type2), ...);

Using catalog with a Container

To use a catalog with the container, simpy pass the catalog to the container's constructor.

var container = new CompositionContainer(catalog);

Updated Wiki: Using Catalogs

weshaggard — Tue, 27 Oct 2009 21:41:38 GMT

Catalogs

Assembly Catalog

To discover all the exports in a given assembly one would use the [System.ComponentModel.Composition.Hosting.AssemblyCatalog].

var catalog = new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly());

Directory Catalog

To discover all the exports in all the assemblies in a directory one would use the [System.ComponentModel.Composition.Hosting.DirectoryCatalog].

var catalog = new DirectoryCatalog("Extensions");

var catalog = new DirectoryCatalog("Extensions");
//some scanning logic
catalog.Refresh();

Aggregate Catalog

var catalog = new AggregateCatalog 
  new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly()), 
  new DirectoryCatalog("Extensions"));

Type Catalog

To discover all the exports in a specific set of types one would use a [System.ComponentModel.Composition.Hosting.TypeCatalog].

var catalog = new TypeCatalog(typeof(type1), typeof(type2), ...);

Using catalog with a Container

To use a catalog with the container, simpy pass the catalog to the container's constructor.

var container = new CompositionContainer(catalog);

Updated Wiki: Using Catalogs

weshaggard — Tue, 27 Oct 2009 21:41:01 GMT

Catalogs

Assembly Catalog

To discover all the exports in a given assembly one would use the [System.ComponentModel.Composition.Hosting.AssemblyCatalog].

var catalog = new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly());

Directory Catalog

To discover all the exports in all the assemblies in a directory one would use the [System.ComponentModel.Composition.Hosting.DirectoryCatalog].

var catalog = new DirectoryCatalog("Extensions");

var catalog = new DirectoryCatalog("Extensions");
//some scanning logic
catalog.Refresh();

Aggregate Catalog

var catalog = new AggregateCatalog 
  new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly()), 
  new DirectoryCatalog("Extensions"));

Type Catalog

To discover all the exports in a specific set of types one would use a [System.ComponentModel.Composition.Hosting.TypeCatalog].

var catalog = new TypeCatalog(typeof(type1), typeof(type2), ...);

Using catalog with a Container

To use a catalog with the container, simpy pass the catalog to the container's constructor.

var container = new CompositionContainer(catalog);

Updated Wiki: Guide

gblock — Tue, 27 Oct 2009 19:03:31 GMT

MEF Programming Guide

Hosting MEF in an application
Defining Parts and Contracts
Declaring Exports
Declaring Imports
Lazy Imports
Exports and Metadata
Using Catalogs
Filtered Catalogs
Part Lifetime
Recomposition
Querying the Composition Container
Composition Batch
Dynamic Instantiation and PartCreator<T>
Debugging and Diagnostics
FAQ

Updated Wiki: Home

gblock — Tue, 27 Oct 2009 14:44:11 GMT

Welcome to the MEF community site

Application requirements change frequently and software is constantly evolving. As a result, such applications often become monolithic making it difficult to add new functionality. The Managed Extensibility Framework (MEF) is a new library in .NET Framework 4.0 that addresses this problem by simplifying the design of extensible applications and components.

Disclaimer: MEF is in development. The source available on this site, does not reflect the final state of the product, it is a preview of what will be shipping in the framework in the future. We welcome any feedback you have on your experience.

Where to go next

Learn more about MEF

Read the MEF Programming Guide

Read our sample documentation

Architecture Overview

Visit the MEF Discussions

See our team Blogs

See field and industry blogs on MEF

Read reference documentation on MSDN, (more)

News

MEF Preview 8 is live, download it here
If you want to know about MEF's underlying composition model, check out the new whitepaper on hosting the .NET composition primivites
MEF is now MS-PL, read about it here
MEF Contrib has launched. http://www.codeplex.com/MEFContrib

New Comment on "Filtering Catalogs"

fa3den — Tue, 27 Oct 2009 13:38:45 GMT

The inner catalog may not need to be disposed, but the Change event needs to be unwired.

New Comment on "Querying the Composition Container"

aL3891 — Mon, 26 Oct 2009 14:29:40 GMT

can you make a query using meta data? i have a scenario where there are multiple repositories and i want to get the one with the metadata name x that ive defined in some settings i have.

Updated Wiki: Home

gblock — Mon, 26 Oct 2009 03:33:54 GMT

Welcome to the MEF community site

Application requirements change frequently and software is constantly evolving. As a result, such applications often become monolithic making it difficult to add new fuctionality. The Managed Extensibility Framework (MEF) is a new library in .NET Framework 4.0 that addresses this problem by simplifying the design of extensible applications and components.

Disclaimer: MEF is in development. The source available on this site, does not reflect the final state of the product, it is a preview of what will be shipping in the framework in the future. We welcome any feedback you have on your experience.

Where to go next

Learn more about MEF

Read the MEF Programming Guide

Read our sample documentation

Architecture Overview

Visit the MEF Discussions

See our team Blogs

See field and industry blogs on MEF

Read reference documentation on MSDN, (more)

News

MEF Preview 8 is live, download it here
If you want to know about MEF's underlying composition model, check out the new whitepaper on hosting the .NET composition primivites
MEF is now MS-PL, read about it here
MEF Contrib has launched. http://www.codeplex.com/MEFContrib

Updated Wiki: Home

haveriss — Thu, 22 Oct 2009 21:17:14 GMT

Welcome to the MEF community site

The Managed Extensibility Framework (MEF) is a new library in .NET that enables greater reuse of applications and components. Using MEF, .NET applications can make the shift from being statically compiled to dynamically composed. If you are building extensible applications, extensible frameworks and application extensions, then MEF is for you.

Disclaimer: MEF is in development. The source available on this site, does not reflect the final state of the product, it is a preview of what will be shipping in the framework in the future. We welcome any feedback you have on your experience.

Where to go next

Learn more about MEF

Read the MEF Programming Guide

Read our sample documentation

Architecture Overview

Visit the MEF Discussions

See our team Blogs

See field and industry blogs on MEF

Read reference documentation on MSDN, (more)

News

MEF Preview 8 is live, download it here
If you want to know about MEF's underlying composition model, check out the new whitepaper on hosting the .NET composition primivites
MEF is now MS-PL, read about it here
MEF Contrib has launched. http://www.codeplex.com/MEFContrib

Updated Wiki: Blogs

haveriss — Thu, 22 Oct 2009 20:51:48 GMT

MEF Team Blogs

Team member	Blog
Krzysztof Cwalina	http://blogs.msdn.com/kcwalina/
Mircea Troffin	http://blogs.msdn.com/mirceat/
Wes Haggard	http://weblogs.asp.net/whaggard/
David Kean	http://davesbox.com/
Daniel Plaisted	http://blogs.msdn.com/dsplaisted/
Glenn Block	http://blogs.msdn.com/gblock/
Hamilton Verissimo	http://blogs.msdn.com/hammett/ http://hammett.castleproject.org/
Nicholas Blumhardt	http://blogs.msdn.com/nblumhardt/

Recent Feeds

Nicholas Blumhardt News Feed

Homeward Bound

Wednesday, September 30, 2009 | From Nicholas Blumhardt

Debug Composition from within Visual Studio

Thursday, September 24, 2009 | From Nicholas Blumhardt

Parameterised Triggers and Re-Entrant States in Stateless v2

Sunday, August 30, 2009 | From Nicholas Blumhardt

Nicholas Blumhardt News Feed

Krzysztof Cwalina : MEF News Feed

MEF Primitives Explained

Tuesday, June 09, 2009 | From Krzysztof Cwalina : MEF

MEF Primitives Explained

Tuesday, June 09, 2009 | From Krzysztof Cwalina : MEF

Custom Programming Models for MEF (Provider Model Contrib)

Tuesday, March 03, 2009 | From Krzysztof Cwalina : MEF

Krzysztof Cwalina : MEF News Feed

Mircea Trofin's blog : MEF News Feed

The Managed Extensibility Framework (MEF) CTP is out!

Thursday, June 05, 2008 | From Mircea Trofin's blog : MEF

The Managed Extensibility Framework (MEF) CTP is out!

Thursday, June 05, 2008 | From Mircea Trofin's blog : MEF

Mircea Trofin's blog : MEF News Feed

Wes' Puzzling Blog : MEF News Feed

MEF preview 5 released

Wednesday, April 08, 2009 | From Wes' Puzzling Blog : MEF

Should MEF support non-shared components?

Monday, November 10, 2008 | From Wes' Puzzling Blog : MEF

MEF CTP2 released with source code.

Wednesday, September 10, 2008 | From Wes' Puzzling Blog : MEF

Wes' Puzzling Blog : MEF News Feed

Dave's Box : Managed Extensibility Framework News Feed

New Managed Extensibility Framework (MEF) Preview

Monday, September 08, 2008 | From Dave's Box : Managed Extensibility Framework

Binding private and internal members using the CompositionContainer

Saturday, June 21, 2008 | From Dave's Box : Managed Extensibility Framework

Dependency Injection in the Managed Extensibility Framework – Named Contracts

Friday, June 20, 2008 | From Dave's Box : Managed Extensibility Framework

Dave's Box : Managed Extensibility Framework News Feed

My Technobabble : MEF News Feed

Open-generic support in MEF Contrib

Thursday, August 20, 2009 | From My Technobabble : MEF

Open-generic support in MEF Contrib

Thursday, August 20, 2009 | From My Technobabble : MEF

Should I use MEF for my general IoC needs?

Sunday, August 16, 2009 | From My Technobabble : MEF

My Technobabble : MEF News Feed

MEF and more News Feed

MEF and ASP.NET MVC sample updated

Wednesday, July 15, 2009 | From MEF and more

MEF and ASP.NET MVC sample updated

Wednesday, July 15, 2009 | From MEF and more

MEF and ASP.NET MVC sample

Thursday, April 23, 2009 | From MEF and more

MEF and more News Feed

Daniel Plaisted's Blog News Feed

Import Cardinality, and Picking Which Export to Use

Tuesday, August 11, 2009 | From Daniel Plaisted's Blog

Import Cardinality, and Picking Which Export to Use

Monday, August 10, 2009 | From Daniel Plaisted's Blog

A Crash Course on the MEF Primitives

Monday, June 08, 2009 | From Daniel Plaisted's Blog

Daniel Plaisted's Blog News Feed

New Comment on "Hosting MEF and the Container"

DenisVuyka — Mon, 19 Oct 2009 19:30:36 GMT

Actually in my opinion the decoupling of core functionality and extra one (extension methods) is cool until both share the same namespace. It is not obvious why there are some methods missing in Catalog until you declare "System.Component.Model.Composition" namespace. This means that documentation and samples should always highlight that two namespaces have to be declared in order to reproduce samples. Thanks, Denis.

New Comment on "Composition Batch"

chudq — Thu, 15 Oct 2009 22:24:40 GMT

It would be nice to use FluentInterface to add and/or remove parts: var batch =CompositionBatch.AddPart(partInstance1). AddPart(partInstance2). RemovePart(part3).GetBatchInstance();