Question

Consider the following existing classes which uses MEF to compose Consumer.

public interface IProducer
{
    void Produce();
}

[Export(typeof(IProducer))]
public class Producer : IProducer
{
    public Producer()
    {
        // perform some initialization
    }

    public void Produce()
    {
        // produce something
    }
}

public class Consumer
{
    [Import]
    public IProducer Producer
    {
        get;
        set;
    }

    [ImportingConstructor]
    public Consumer(IProducer producer)
    {
        Producer = producer;
    }

    public void DoSomething()
    {
        // do something
        Producer.Produce();
    }
}

However, the creation of Producer has become complex enough that it can no longer be done within the constructor and the default behavior no longer suffices.

I’d like to introduce a factory and register it using a custom FactoryAttribute on the producer itself. This is what I have in mind:

[Export(typeof(IProducer))]
[Factory(typeof(ProducerFactory))]
public class Producer : IProducer
{
    public Producer()
    {
        // perform some initialization
    }

    public void Produce()
    {
        // produce something
    }
}

[Export]
public class ProducerFactory
{
    public Producer Create()
    {
        // Perform complex initialization
        return new Producer();
    }
}

public class FactoryAttribute : Attribute
{
    public Type ObjectType
    {
        get;
        private set;
    }

    public FactoryAttribute(Type objectType)
    {
        ObjectType = objectType;
    }
}

If I had to write the “new” code myself, it may very well look as follows. It would use the factory attribute, if it exists, to create a part, or default to the MEF to create it.

public object Create(Type partType, CompositionContainer container)
{
    var attribute = (FactoryAttribute)partType.GetCustomAttributes(typeof (FactoryAttribute), true).FirstOrDefault();
    if (attribute == null)
    {
        var result = container.GetExports(partType, null, null).First();
        return result.Value;
    }
    else
    {
        var factoryExport = container.GetExports(attribute.ObjectType, null, null).First();
        var factory = factoryExport.Value;
        var method = factory.GetType().GetMethod("Create");
        var result = method.Invoke(factory, new object[0]);
        container.ComposeParts(result);
        return result;
    }
}

There are a number of articles how to implement a ExportProvider, including:

1. MEF + Object Factories using Export Provider
2. Dynamic Instantiation

However, the examples are not ideal when

1. The application has no dependencies or knowledge of Producer, only IProducer. It would not be able to register the factory when the CompositionContainer is created.
2. Producer is reused by several applications and a developer may mistakenly forget to register the factory when the CompositionContainer is created.
3. There are a large number of types that require custom factories and it may pose a maintenance nightmare to remember to register factories when the CompositionContainer is created.

I started to create a ExportProvider (assuming this would provide the means to implement construction using factory).

public class FactoryExportProvider : ExportProvider
{
    protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition,
                                                          AtomicComposition atomicComposition)
    {
        // What to do here? 
    }
}

However, I’m having trouble understanding how to tell MEF to use the factory objects defined in the FactoryAttribute, and use the default creation mechanism if no such attribute exists.

What is the correct manner to implement this? I’m using MEF 2 Preview 5 and .NET 4.

Answer 1

You can make use of a property export:

public class ProducerExporter
{
   [Export]
   public IProducer MyProducer
   {
       get
       {
           var producer = new Producer();
           // complex initialization here
           return producer;
       }
   }
}

Note that the term factory isn’t really appropriate for your example, I would reserve that term for the case where the importer wants to create instances at will, possibly by providing one or more parameters. That could be done with a method export:

public class ProducerFactory
{
   [Export(typeof(Func<Type1,Type2,IProducer>)]
   public IProducer CreateProducer(Type1 arg1, Type2 arg2)
   {
       return new Producer(arg1, arg2);
   }
}

On the import side, you would then import a Func<Type1,Type2,IProducer> that you can invoke at will to create new instances.