如何更改实例进程的创建？ （例如：DI、工厂……）

Question

During the compose process, MEF create instances of types imported using the constructor by default or the "ImportingConstructor".

I want to override this process of creation.

For example:

• Use DI pattern (using Unity)

• Use Factory pattern

Is it possible to do that with MEF?

Answer 1

Short answer: it is possible but requires effort.

Longer:

• In order to provide objects for imports (exported values), MEF operates on instances of Export class. The exported value is retrieved using Export.Value property.
• If you wish to ad-hoc register particular instance of object within CompositionContainer , you may do that using AddExportedValue or ComposeExportedValue .
• If you wish to intercept the process of creation of objects by MEF, this is totally different story.

We could simplify structure of MEF artifacts to:

• ComposablePartCatalog provides ComposablePartDefinition objects
• ComposablePartDefinition objects are used by ExportProvider to create corresponding ComposablePart objects
• ComposablePart objects are responsible for producing actual exported values ( GetExportedValue )

All above classes are abstract. If you will analyze concrete classes used by MEF (eg use CompositionContainer with TypeCatalog ), you will figure out that most of the implementation is internal and there is not much chances to inject custom logic. Still, there are some options.

You may implement proxy object for the specific, concrete MEF's type. For instance, if you need to intercept all exported values the CompositionContainer provides:

• Create class, say CompositionContainerProxy (derived, from CompositionContainer )
• Override GetExportsCore method, provide interception of exports

Sample:

public class CompositionContainerProxy : CompositionContainer
{
    protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
    {
        IEnumerable<Export> exports = base.GetExportsCore(definition, atomicComposition);

        List<Export> proxies = new List<Export>();
        
        foreach (Export export in exports)
        {
            proxies.Add(new ExportProxy(export, this));
        }

        return proxies;
    }

    private object Intercept(object value)
    {
        return value; // TODO: Provide intercept logic.
    }

    private class ExportProxy : Export
    {
        private readonly Export export;

        private readonly CompositionContainerProxy proxy;

        public override ExportDefinition Definition
        {
            get { return export.Definition; }
        }

        internal ExportProxy(Export export, CompositionContainerProxy proxy)
        {
            this.export = export;
            this.proxy = proxy;
        }

        protected override object GetExportedValueCore()
        {
            object value = export.Value;

            return proxy.Intercept(value);
        }
    }
}

This way you may eg assure thread safety etc. See, eg: Controller.cs

QComposite use such tricks for eg implementing hierarchical structure of controllers, export visibility scope etc. https://www.qube7.com/guides/controller-composition.html