Codice di Cruft. CIO di soccorso

Question

In question circa l'utilità di IoC Container, il mittente vincente ha detto che con un contenitore CIO si può prendere questo:

public class UglyCustomer : INotifyPropertyChanged 
{ 
    private string _firstName; 
    public string FirstName 
    { 
     get { return _firstName; } 
     set 
     { 
      string oldValue = _firstName; 
      _firstName = value; 
      if(oldValue != value) 
       OnPropertyChanged("FirstName"); 
     } 
    } 

    private string _lastName; 
    public string LastName 
    { 
     get { return _lastName; } 
     set 
     { 
      string oldValue = value; 
      _lastName = value; 
      if(oldValue != value) 
       OnPropertyChanged("LastName"); 
     } 
    } 
} 

a questo:

var bindingFriendlyInstance = IoC.Resolve<Customer>(new NotifyPropertyChangedWrapper()); 

Domande:

• Quale magico contenitore IoC fornisce questa bontà?
• Un esempio di implementazione di questo?
• Eventuali aspetti negativi?
• In un progetto con dipendenze complesse, piangerò quando cerco di applicare l'associazione dati a questi oggetti?

Answer 1

Per il secondo frammento di codice a lavorare, NotifyPropertyChangedWrapper sarebbe certamente necessario utilizzare riflessione (o dynamic) per generare una classe che fornisce un'interfaccia compatibile con Customer ed implementa la notifica di proprietà automatica. Non ci dovrebbero essere problemi di associazione dei dati, ma ci sarebbe un piccolo sovraccarico.

Un'implementazione semplificata che utilizza un oggetto dinamico potrebbe essere simile a questo:

public class NotifyPropertyChangedWrapper<T> 
    : DynamicObject, INotifyPropertyChanged 
{ 
    private T _obj; 

    public NotifyPropertyChangedWrapper(T obj) 
    { 
     _obj = obj; 
    } 

    public override bool TryGetMember(
     GetMemberBinder binder, out object result) 
    { 
     result = typeof(T).GetProperty(binder.Name).GetValue(_obj); 
     return true; 
    } 

    // If you try to set a value of a property that is 
    // not defined in the class, this method is called. 
    public override bool TrySetMember(
     SetMemberBinder binder, object value) 
    { 
     typeof(T).GetProperty(binder.Name).SetValue(_obj, value); 
     OnPropertyChanged(binder.Name); 
     return true; 
    } 

    // Implement OnPropertyChanged... 
} 

Ovviamente, qualsiasi codice che consuma uno di questi oggetti perderebbe qualsiasi tipo di sicurezza statica. L'altra opzione è quella di generare una classe che implementa la stessa interfaccia della classe in corso di wrapping. Ci sono molti esempi per questo sul web. Il requisito principale è che il tuo Customer debba essere uno interface o che abbia bisogno che tutte le sue proprietà siano virtuali.

Answer 2

Non l'ho mai usato, ma si può presumibilmente creare qualcosa di simile usando PostSharp.

Answer 3

Per fare ciò in modo generico (vale a dire un singolo pezzo di codice che implementa INotifyPropertyChanged per qualsiasi classe) utilizzare un proxy. Esistono molte implementazioni per fare ciò con Castle.DynamicProxy o LinFu o Unity. Queste librerie proxy hanno un buon supporto nei contenitori IoC, ad esempio DynamicProxy ha una buona integrazione con Castle Windsor e l'intercettazione Unity (o come si chiama) ha ovviamente una buona integrazione con il contenitore Unity.

Answer 4

Se si sta cercando una soluzione specifica per la creazione automatica di oggetti collegabili, consultare PropertyChanged.Fody (in precedenza NotifyPropertyWeaver). Questo riscrive le classi che implementano INotifyPropertyChanged per includere il codice di notifica. C'è un esempio nella pagina di github.

A mio parere, questo è più ordinato rispetto all'utilizzo della soluzione di contenitore IOC proposta. Tuttavia, è una libreria specifica per l'associazione INotifyPropertyChanged, quindi non è applicabile come soluzione generale, come è stato discusso nella domanda collegata.