Kann ich eine Unity-Erweiterung codieren, um den Effekt des Anwendens des Abhängigkeitsattributs auf alle öffentlichen Eigenschaften zu erhalten?

Question

Ich denke, es sollte einfach sein, aber ich kenne nicht die genaue Mechanik, dies zu tun (siehe Fragetitel).

So wie es funktionieren würde, könnte wie folgt sein:

[AutoInjectProperties] 
public class C 
{ 
    public class C(bool b) 
    { 
    if(b) 
    { 
     this.MyClass3 = new MyClass3(); // prevents auto inject 
    } 
    } 
    public MyClass1 { get; set; } // auto inject 
    public MyClass2 { get; } 
    public MyClass3 { get; set; } // auto inject if null after construction 
} 

Answer 1

Ich würde nicht die DependencyAttribute überhaupt. It is not a recommended practice. Verwenden Sie stattdessen die DependencyProperty.

container.RegisterType<IMyInterface, MyImplementation>(new DependencyProperty("Foo")); 

Wenn die Abhängigkeiten, die Sie injizieren müssen ausgefüllt werden, sollten Sie Konstruktor Injektion statt Eigenschaft Injektion verwendet werden. Unity ermittelt selbst Konstruktorparameter.

public class MyImplementation 
{ 
    private readonly IFoo foo; 
    public MyImplementation(IFoo foo) 
    { 
    if(foo == null) throw new ArgumentNullException("foo"); 
    this.foo = foo; 
    } 
    public IFoo Foo { get { return this.foo; } } 
} 

Wenn Sie IFoo registrieren, bevor Sie lösen MyImplementation Einheit wird ihre Arbeit tun und es für Sie zu injizieren.

---

aktualisieren

public class AllProperties : InjectionMember 
{ 
    private readonly List<InjectionProperty> properties; 
    public AllProperties() 
    { 
    this.properties = new List<InjectionProperty>(); 
    } 
    public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) 
    { 
    if(implementationType == null)throw new ArgumentNullException("implementationType"); 
    // get all properties that have a setter and are not indexers 
    var settableProperties = implementationType 
     .GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) 
     .Where(pi => pi.CanWrite && pi.GetSetMethod(false) != null && pi.GetIndexParameters().Length == 0); 
    // let the Unity infrastructure do the heavy lifting for you 
    foreach (PropertyInfo property in settableProperties) 
    { 
     this.properties.Add(new InjectionProperty(property.Name)); 
    } 
    this.properties.ForEach(p => p.AddPolicies(serviceType, implementationType, name, policies)); 
    } 
} 

Verwenden Sie es wie die

container.RegisterType<Foo>(new AllProperties()); 

Es werden alle Eigenschaften injizieren, die einen öffentlichen Setter haben.