Différence entre les attributs Import et ImportingConstructor dans MEF avec des exemples appropriés?

Question

Quelqu'un peut-il m'aider avec les attributs Import et ImportingConstructor dans MEF avec des exemples pertinents et quand l'utiliser? Quelle est l'utilisation de [Import (AllowDefault = true)]?

De ma compréhension du MEF:

attribut d'exportation est défini sur la classe de type T où T est l'interface et de créer une instance de cet attribut de classe d'importation doit être définie sur la variable de référence comme ci-dessous

[Export(typeof(ICalculator))] 
class MySimpleCalculator : ICalculator 
{ 
    // Implement the interface 
} 

class MyMainClass 
{ 
    // MEF engine creates an instance as Export attribute is defined 
    // on MySimpleCalculator 

    [Import(typeof(ICalculator))] 
    public ICalculator calculator; 
} 

Si plusieurs exportations de type T sont définies dans un assemblage donné, nous pouvons utiliser l'attribut ImportMany.

Alors maintenant, quelqu'un peut-il expliquer quand utiliser Import et ImportingConstructor ainsi que l'attribut AllowDefault dans le constructeur?

Ce serait génial si quelqu'un peut expliquer avec de meilleurs exemples.

Toute aide serait appréciée. Merci

Answer 1

ImportingConstructor

La façon dont vous l'importation/pièces d'exportation dans votre exemple de code, si MyMainClass est se compose, le constructeur parameterless implicite est appelée, alors une instance de MySimpleCalculator est affecté à la calculator champ. Maintenant, supposons que vous préfériez avoir un champ readonly/une propriété get-only, ou que vous ayez besoin d'accéder au ICalculator dans le constructeur, vous devez le faire passer au constructeur plutôt que de l'affecter au champ. :

public interface ICalculator 
{ 
    bool Quack { get; } 
} 

[Export(typeof(ICalculator))] 
public class MySimpleCalculator : ICalculator 
{ 
    public bool Quack => true; 
} 

[Export] 
public class MyMainClass 
{ 
    public ICalculator Calculator { get; } 
    public string Blah { get; } 

    [ImportingConstructor] 
    public MyMainClass(ICalculator calculator) 
    { 
     Calculator = calculator; // assign readonly property 
     Blah = calculator.Quack ? "Foo" : "Bar"; // do something based on calculator 
    } 
} 

Maintenant, le (s) argument (s) du constructeur sont implicitement importés et satisfaits d'une exportation correspondante.

AllowDefault

Si vous [Import] quelque chose, que quelque chose doit être disponible ou ne composition.

Si vous [Import (AllowDefault = true)] quelque chose, la composition ne va pas échouer s'il n'y a pas d'exportation correspondante, mais vous obtenez null/false/0 comme valeur importée.

BTW: désolé d'être légèrement sarcastique, mais la réponse pourrait aussi être RTFM.