MEF and factories, import created object directly

Question

I’ve started working with MEF. In my application I’ve a factory for some Models. My factory has 2 create methods; one takes a name as parameter, the other a type.

[Export(typeof(IFactory))]
[PartCreationPolicy(CreationPolicy.Shared)]
public class MyFactory : IFactory
{
    public IModel Create(String name) {...}
    public IModel Create(Type type) {...}
}

public class Foo
{
    [Import(typeof(IFactory))]
    public IFactory Factory { get; set; }

    public Foo()
    {
        IModel modelByName = Factory.Create("name");
        IModel modelByType = Factory.Create(typeof(Foo));
    }
}

At the moment I’ve to import a factory and then call create on the factory object to get a model. Now I’m wondering if there is a way to import a model directly, something like:

[Import(typeof(IModel), Name:"Name")]
public IModel Model { get; set; }

edit ---------------------------------------------------

The goal would be to replace something like this:

public class Foo
{
    [Import(typeof(IFactory))]
    public IFactory Factory { get; set; }

    public IModel Model { get; set; }
    public IModel Model1 { get; set; }

    public Foo()
    {
        Model = Factory.Create("Foo");
        Model1 = Factory.Create(typeof(Foo1));
    }
}

Whit something like this:

public class Foo
{
    //Should internal import a IFactory(singeleton) object 
    //and call the Create(name:String) method on it
    [Import(typeof(IModel), Name:"Foo")]
    public IModel Model { get; set; }

    //Should internal import a IFactory(singeleton) object 
    //and call the Create(type:Type) method on it
    [Import(typeof(IModel), Type: typeof(Foo1))]
    public IModel Model1 { get; set; }
}

score 1 · Answer 1 · answered Feb 03 '13 at 19:57

You can't pass parameters of the [Import] attribute to methods of the type being imported.

I think you should not do so if you could however, because doing an import like that causes your class to be constructed and it'll most likely be prematurely constructed. You should delay construction of the object until the time it is actually needed. By doing a direct import, you lose this lazy behavior.

Also, a factory typically requires some parameters to construct a type, but this is not the case here. If you absolutely have to have the direct import, you can just import the type itself, instead of the factory (of course you'll lose the option of later on manipulating the construction easily by changing the factory's behavior).

Thank you for your answer. …I think my question was not accurate enough I don’t want to replace the factory, but I would like to get the return value of the Create method imported directly, so I don’t have to create a factor every time, just to call Create on it. — musium, Feb 03 '13 at 20:05

Panos Rontogiannis · Answer 2 · 2013-02-04T22:32:56.103

0

You can add contract names to your exports and then use them when you import a part.

For the IModel interface:

public interface IModel { }

You can export an implementation as an IModel using a contract name:

[Export("Foo1", typeof(IModel))]
public class Foo1 : IModel { }

You can also add more than one export attributes on a single class. This way you can satisfy both kind of imports (by name and by type).

[Export("Foo2", typeof(IModel))]
[Export(typeof(Foo2))]
public class Foo2 : IModel { }

Then you import like this:

public class Foo
{
    //Import using the contract name.
    [Import("Foo1", typeof(IModel))]
    public IModel Model1 { get; set; }

    //Import using the actual type.
    [Import(typeof(Foo2))]
    public IModel Model2 { get; set; }

    //Import the same model but with contract name instead of type. 
    //This is possible because there are two different exports.
    [Import("Foo2")]
    public IModel Model3 { get; set; }
}

As you can see you do not have to use ant factory at all. MEF will be your factory.

edited Feb 04 '13 at 22:32

answered Feb 03 '13 at 22:31

Panos Rontogiannis

4,154
1
24
29

Why should I use the dynamic keyword, I know that the imported object is type of IModel. What I’m looking for is a way to place an attribute on a property and give this attribute a string or a type as parameter. This attribute should now pass the parameter to the Create method and store the return value of Create in the property… I’ve added a pseudo sample to the question. – musium Feb 03 '13 at 23:06
Thanks for your answer. You’re right; this would work, if I had a class which is decorated with an export attribute. But have you seen the edited question? The factory does some important stuff, based on the given string or type (Create (type: Type), Create(name: String))… Is there a way to import an object created by the factory (note: I should be able to specify the string or type on the import side) – musium Feb 05 '13 at 11:11
@user1320170 Then I believe what you really need is an IoC container such as Autofac (which by the way integrates with MEF). There can be a way to do this with MEF but you will have to add another layer of abstraction and it your solution will become complicated. And you plan to use this pattern in many places then it will be even worse. – Panos Rontogiannis Feb 05 '13 at 11:33

MEF and factories, import created object directly

2 Answers2