C＃MVVM计算总计

Question

我需要根据选定的价格和数量计算交易价值。 怎么能

以下是我的ViewModel：

class ViewModel : ViewModelBase
{
    public Trade Trade
    {
        get { return _trade; }
        set { SetField(ref _trade, value, () => Trade); }
    } private Trade _trade;

    public decimal TradeValue
    {
        get { return Trade.Amount * Trade.Price; }
    } 

}

ViewModelBase继承INotifyPropertyChanged并包含SetField（）

以下是贸易类：

public class Trade : INotifyPropertyChaged
{
    public virtual Decimal Amount
    {
        get { return _amount; }
        set { SetField(ref _amount, value, () => Amount); }
    } private Decimal _amount;
    public virtual Decimal Price
    {
        get { return _price; }
        set { SetField(ref _price, value, () => Price); }
    } private Decimal _price;
    ......
}

我知道由于设计我的TradeValue只计算一次（当它第一次请求时），并且当金额/价格变化时UI不会更新。 实现这一目标的最佳方法是什么？

任何帮助非常感谢。

更新： INotifyPropertyChanged实现：

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }
    protected virtual void OnPropertyChanged<T>(Expression<Func<T>> selectorExpression)
    {
        if (selectorExpression == null)
            throw new ArgumentNullException("selectorExpression");
        var body = selectorExpression.Body as MemberExpression;
        if (body == null)
            throw new ArgumentException("The body must be a member expression");
        OnPropertyChanged(body.Member.Name);
    }
    protected bool SetField<T>(ref T field, T value, Expression<Func<T>> selectorExpression)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return false;
        field = value;
        OnPropertyChanged(selectorExpression);
        return true;
    }

这两个答案都有效，现在我不知道选择哪一个作为最佳答案。 Luke的答案似乎更好，因为似乎只有更少的代码重复，尽管只是监听OnPropertyChanged事件似乎更轻量级。

Answer 1

这就是我通常这样做的方式：

private bool has_inited_tradevalue_linkage = false;
public decimal TradeValue
{
    get 
    { 
        if(!has_inited_tradevalue_linkage)
        {
            has_inited_tradevalue_linkage = true;
            this.PropertyChanged += (_, e) => 
            {
                if(e.PropertyName.Equals("Amount") || e.PropertyName.Equals("Price"))
                    OnPropertyChanged("TradeValue");
            };
        }
        return Trade.Amount * Trade.Price; }
}

这种方式链接是懒惰地构造的（所以你不发布没有人感兴趣的事件），并且所有的逻辑仍然包含在这个属性中。 相反，您可以在Price和Amount的设置者中添加对OnPropertyChanged("TradeValue")调用，但这对于课堂上的其他人来说有点糟糕（至少在我看来）。 我已经非常成功地使用了这种模式，以创建类似的“依赖”属性。

另一个选择就是专门跟踪依赖项：

在ViewModelBase中你可以添加这个：

私人词典> DependencyMap = new Dictionary>（）; protected void AddPropertyDependency（String prop，String dependantProp）{if（DependencyMap.ContainsKey（prop））{DependencyMap [prop] .Add（dependantProp）; } else {DependencyMap [prop] = new List {dependantProp}; }}

然后在你的OnPropertyChanged方法中：

protected void OnPropertyChanged(String prop)
{
    var eh = PropertyChanged;
    if(eh != null)
    {
        eh(this, new PropertyChangedEventArgs(prop);
        if(DependencyMap.ContainsKey(prop))
        {
            foreach(var p in DependencyMap[prop])
                OnPropertyChanged(p);//recursive call would allow for arbitrary dependencies
        }
    }
}

然后在您的类构造函数中，您只需定义属性依赖项：

public ViewModel()
{
    AddPropertyDependency("Amount", "TradeValue");
    AddPropertyDependency("Price", "TradeValue");
}

这绝对是一个更通用的解决方案，大多数更改都在您的基类中。

Answer 2

private void UpdateValue()
        {
            this.Value = this.Acres * this.YieldPerAcre * this.UnitPrice;
        }      
       public double Acres
        {
            get { return _cropProductionRecord.Acres; }
            set
            {
                _cropProductionRecord.Acres = value;
                OnPropertyChanged("Acres");
                UpdateValue();
            }
        }
        public double YieldPerAcre
        {
            get { return _cropProductionRecord.YieldPerAcre; }
            set
            {
                _cropProductionRecord.YieldPerAcre = value;
                OnPropertyChanged("YieldPerAcre");
                UpdateValue();
            }
        }

        public double UnitPrice
        {
            get { return _cropProductionRecord.UnitPrice; }
            set
            {
                _cropProductionRecord.UnitPrice = value;
                OnPropertyChanged("UnitPrice");
                UpdateValue();
            }
        }
        public double Value
        {
            get { return _cropProductionRecord.Value; }
            set
            {
                _cropProductionRecord.Value = value;
                OnPropertyChanged("Value");
            }
        }

Answer 3

在VM类的Trade属性的set方法中，在Trade类上订阅PropertyChanged事件。 在该事件处理程序中，为属性TradeValue发布propertychanged。