INotifyPropertyChanged y propiedad calculada

Question

Supongamos que tengo Simple clase, que tienen un TotalPrice propiedad calculada, que puede ser obligado a WPF UI

public class Order : INotifyPropertyChanged 
{ 
    public decimal ItemPrice 
    { 
    get { return this.itemPrice; } 
    set 
    { 
     this.itemPrice = value; 
     this.RaisePropertyChanged("ItemPrice"); 
     this.RaisePropertyChanged("TotalPrice"); 
    } 
    } 

    public int Quantity 
    { 
    get { return this.quantity; } 
    set 
    { 
     this.quantity= value; 
     this.RaisePropertyChanged("Quantity"); 
     this.RaisePropertyChanged("TotalPrice"); 
    } 
    } 

    public decimal TotalPrice 
    { 
    get { return this.ItemPrice * this.Quantity; }  
    } 
} 

¿Es una buena práctica para llamar RaisePropertyChanged ("TotalPrice") en el propiedades que afectan al cálculo de TotalPrice? ¿Cuál es la mejor manera de actualizar la propiedad TotalPrice? La otra versión de hacer esto, por supuesto, es cambiar propiedad como esta

public decimal TotalPrice 
{ 
    get { return this.ItemPrice * this.Quantity; } 
    protected set 
    { 
     if(value >= 0) 
      throw ArgumentException("set method can be used for refresh purpose only"); 

    } 
} 

y llame TotalPrice = -1 en vez de this.RaisePropertyChanged ("TotalPrice"); en otras propiedades. Por favor, sugerir soluciones mejor

Muchas gracias

Answer 1

Está bien que comprobar para ver si debe aumentar este evento, así de cualquier otro miembro que puede cambiar el valor, pero sólo lo hacen si realmente cambio la valor.

Se puede encapsular esto en un método:

private void CheckTotalPrice(decimal oldPrice) 
{ 
    if(this.TotalPrice != oldPrice) 
    { 
     this.RaisePropertyChanged("TotalPrice"); 
    } 
} 

Luego hay que llamar a que a partir de sus otros miembros mutantes:

var oldPrice = this.TotalPrice; 
// mutate object here... 
this.CheckTotalPrice(oldPrice); 

Answer 2

Otra solución es la que Robert Rossney propone en esta pregunta:

WPF INotifyPropertyChanged for linked read-only properties

puede crea te un mapa propiedad de dependencia (con sus ejemplos de código):

private static Dictionary<string, string[]> _DependencyMap = 
new Dictionary<string, string[]> 
{ 
    {"Foo", new[] { "Bar", "Baz" } }, 
}; 

y luego hacer esto en su OnPropertyChanged:

PropertyChanged(this, new PropertyChangedEventArgs(propertyName)) 
if (_DependencyMap.ContainsKey(propertyName)) 
{ 
    foreach (string p in _DependencyMap[propertyName]) 
    { 
     PropertyChanged(this, new PropertyChangedEventArgs(p)) 
    } 
} 

Incluso es posible adjuntar un atributo para atar la propiedad depende de la que depende en. Algo como:

[PropertyChangeDependsOn("Foo")] 
public int Bar { get { return Foo * Foo; } } 
[PropertyChangeDependsOn("Foo")] 
public int Baz { get { return Foo * 2; } } 

Todavía no he implementado los detalles del atributo. Será mejor que empiece a trabajar en eso ahora.

Answer 3

Si utiliza NotifyPropertyWeaver puede tener este código

public class Order : INotifyPropertyChanged 
{ 
    public event PropertyChangedEventHandler PropertyChanged; 

    public decimal ItemPrice { get; set; } 

    public int Quantity { get; set; } 

    public decimal TotalPrice 
    { 
     get { return ItemPrice*Quantity; } 
    } 
} 

y será compilado a esto.

public class Order : INotifyPropertyChanged 
{ 
    decimal itemPrice; 
    int quantity; 
    public event PropertyChangedEventHandler PropertyChanged; 

    public virtual void OnPropertyChanged(string propertyName) 
    { 
     var propertyChanged = PropertyChanged; 
     if (propertyChanged != null) 
     { 
      propertyChanged(this, new PropertyChangedEventArgs(propertyName)); 
     } 
    } 

    public decimal ItemPrice 
    { 
     get { return itemPrice; } 
     set 
     { 
      if (itemPrice != value) 
      { 
       itemPrice = value; 
       OnPropertyChanged("TotalPrice"); 
       OnPropertyChanged("ItemPrice"); 
      } 
     } 
    } 

    public int Quantity 
    { 
     get { return quantity; } 
     set 
     { 
      if (quantity != value) 
      { 
       quantity = value; 
       OnPropertyChanged("TotalPrice"); 
       OnPropertyChanged("Quantity"); 
      } 
     } 
    } 

    public decimal TotalPrice 
    { 
     get { return ItemPrice*Quantity; } 
    } 
} 

Answer 4

¿Es una buena práctica para llamar RaisePropertyChanged ("TotalPrice") en las propiedades que afectan al cálculo TotalPrice?

No, no es escala, y es una pesadilla de mantenimiento.

https://github.com/StephenCleary/CalculatedProperties es mejor motor de fórmula a partir de ahora para MVVM (en mi opinión) que notifica acerca de los cambios de propiedades derivadas/calculados y es compatible con cualquier nivel de anidamiento

public decimal ItemPrice 
    { 
    get { return Property.Get(0m); } 
    set { Property.Set(value); } 
    } 

    public int Quantity 
    { 
    get { return Property.Get(0); } 
    set { Property.Set(value); } 
    } 

    public decimal TotalPrice 
    { 
    get { return Property.Calculated(() => ItemPrice * Quantity); }  
    }