MEF Konstruktor-Parameter mit Mehreren Konstruktoren

Ich bin seit MEF, und ich habe eine Klasse mit mehreren Konstruktoren, wie diese:

[Export(typeof(ifoo))]
class foo : ifoo {
    void foo() { ... }
    [ImportingConstructor]
    void foo(object par1) { ... }
}

Ich bin mit catalog.ComposeExportedValue() beim Komponieren zur Versorgung der par1
Wert auf den zweiten Konstruktor:

...
catalog.ComposeExportedValue(par1Value);
catalog.ComposeParts(this);
...

Halten die Komponenten die ich verwende:

[ImportMany(typeof(ifoo))]
public List<Lazy<ifoo, ifoometadata>> FooList { get; set; }

Zu erstellen und das foo Beispiel bin ich mit der value-Eigenschaft, FooList[0].Value.

Alles funktioniert gut, außer, dass der zweite Konstruktor der foo Klasse nie aufgerufen wird. Was ist falsch?

Wie wähle ich den Konstruktor, den ich nutzen möchte, wenn MEF instanziiert die Klasse?

  • Haben Sie einen Blick auf stackoverflow.com/questions/2008133/mef-constructor-injection ... es ist nicht genau die gleiche Frage, aber die akzeptierte Antwort wirft ein Licht auf den Import von Konstruktoren, die helfen können.
  • ja, in der Tat, ich bin mit der Antwort von Daniel Plaisted, das problem ist ich kann nicht finden, Beispiele von mef-Instanz anlegen über mehrere Konstruktor-Definitionen.
InformationsquelleAutor InterWAS | 2010-05-31
  1. 8

    MEF sollten den Konstruktor verwenden Sie den ImportingConstructorAttribute auf. Ich bin mir nicht sicher, was passiert, für Sie, ich war nicht in der Lage das Problem zu reproduzieren. Hier ist ein test, der zeigt, wie mit einer ImportingConstructor auf eine Klasse, die auch einen default-Konstruktor:

    [TestClass]
public class MefTest
{
    public const string ConstructorParameterContract = "FooConstructorParameterContract";

    [TestMethod]
    public void TestConstructorInjectionWithMultipleConstructors()
    {
        string ExpectedConstructorParameterValue = "42";

        var catalog = new TypeCatalog(typeof(Foo), typeof(FooImporter));
        var container = new CompositionContainer(catalog);

        container.ComposeExportedValue<string>(ConstructorParameterContract, ExpectedConstructorParameterValue);

        var fooImporter = container.GetExportedValue<FooImporter>();

        Assert.AreEqual(1, fooImporter.FooList.Count, "Expect a single IFoo import in the list");
        Assert.AreEqual(ExpectedConstructorParameterValue, fooImporter.FooList[0].Value.ConstructorParameter, "Expected foo's ConstructorParameter to have the correct value.");
    }
}

public interface IFoo
{
    string ConstructorParameter { get; }
}

[Export(typeof(IFoo))]
public class Foo : IFoo
{
    public Foo()
    {
        ConstructorParameter = null;
    }

    [ImportingConstructor]
    public Foo([Import(MefTest.ConstructorParameterContract)]string constructorParameter)
    {
        this.ConstructorParameter = constructorParameter;
    }


    public string ConstructorParameter { get; private set; }
}

[Export]
public class FooImporter
{
    [ImportMany]
    public List<Lazy<IFoo>> FooList { get; set; }
}
    • Danke Daniel, seine Arbeit auf diese Weise, aber jetzt steckte ich auf ein weiteres problem: MEF Konstruktor import nicht funktionieren, wenn über abgeleitete Klassen, wie wenn wir eine Foo2 Klasse, die erbt von Foo in Ihrem Beispiel und ändern Sie den rest zu exportieren/importieren, alle abgeleitete Klasse von Foo, der Konstruktor mit den Parametern der Basis-Klasse (Foo) nicht genannt. Vielleicht ist es durch design, dont, überprüfen Sie die Konstruktoren aller Basisklassen alle Weg nach unten. Aber ich bin mit einem Feld import in der Basisklasse (Foo), und es funktioniert, so iam mit diesen workround statt der Konstruktor-Importe, zumindest für jetzt. Vielen Dank für deine Hilfe, Daniel.
    • Es ist by design. Das ist, wie Konstruktoren in .NET Arbeit - Sie rufen genau einem Konstruktor, wenn Sie ein Objekt erstellen, und es kann nicht sein, eine Basisklasse Konstruktor. Eine abgeleitete Klasse eine Basisklasse s Konstruktor im Konstruktor. Eigenschaft/Feld Importe wahrscheinlich mehr Sinn machen in deinem Fall.
    InformationsquelleAutor Daniel Plaisted
  2. 3

    Sind Sie übergeben eine Instanz der foo-Klasse in die ComposeExportedValue Methode? In diesem Fall das Objekt bereits gebaut ist und der Konstruktor nicht aufgerufen werden kann, also wieder MEF ignorieren Sie den Konstruktor Einfuhren.

    • Nein, in ComposeExportedValue() gebe ich die Werte, die ich will, um zu injizieren, in Konstruktoren: Katalog.ComposeExportedValue(par1Value); Mein problem ist, dass jeder suplied Konstruktor-Parameter werden einfach ignoriert und die Klasse foo ist instantied mit nur den ersten Konstruktor.
    InformationsquelleAutor Daniel Plaisted
Schreibe einen Kommentar