6

目前我有一个网格，我正在尝试有一个带有验证规则的单元格。为了验证它，我需要行的最小值和最大值。

验证类：

public decimal Max { get; set; }

public decimal Min { get; set; }

public override ValidationResult Validate(object value, System.Globalization.CultureInfo cultureInfo)
{
    var test = i < Min;
    var test2 = i > Max;

    if (test || test2)
        return new ValidationResult(false, String.Format("Fee out of range Min: ${0} Max: ${1}", Min, Max));
    else
        return new ValidationResult(true, null);
}

用户控制：

<telerik:RadGridView SelectedItem ="{Binding SelectedScript}"
                     ItemsSource="{Binding ScheduleScripts}">
    <telerik:RadGridView.Columns>
        <telerik:GridViewDataColumn
            DataMemberBinding="{Binding Amount}" Header="Amount" 
            CellTemplate="{StaticResource AmountDataTemplate}" 
            CellEditTemplate="{StaticResource AmountDataTemplate}"/>   
        <telerik:GridViewComboBoxColumn
            Header="Fee Type" 
            Style="{StaticResource FeeTypeScriptStyle}" 
            CellTemplate="{StaticResource FeeTypeTemplate}"/>           
    </telerik:RadGridView.Columns>
</telerik:RadGridView>

费用类型类：

public class FeeType
{
    public decimal Min { get; set; }
    public decimal Max { get; set; }
    public string Name { get; set; }
}

我在这里用依赖属性尝试了这个解决方案 WPF ValidationRule并且效果很好。但是现在我遇到了代理无法通过视图模型实例化的问题。它基于行的选定组合框值的最小值和最大值属性。

例如，该组合框示例值如下

Admin Min: $75 Max $500
Late  Min: $0  Max $50

由于网格实际上可以有尽可能多的行，所以我看不出在我的情况下创建代理是如何工作的。如果我能得到一些指导提示，将不胜感激。

4

1 回答 1

4

警告：这不是一个确定的解决方案，但向您展示了一种将验证逻辑完全放在 ViewModel 上的正确方法。

出于简洁的目的，我创建了 FeeTypes 列表作为FeeType类的静态属性：

public class FeeType
{
    public decimal Min { get; set; }
    public decimal Max { get; set; }
    public string Name { get; set; }

    public static readonly FeeType[] List = new[]
    {
        new FeeType { Min = 0, Max = 10, Name = "Type1", },
        new FeeType { Min = 2, Max = 20, Name = "Type2", },
    };
}

这是单个 Grid 行的 ViewModel。我只放了 Amount 和 Fee 属性。

public class RowViewModel : INotifyPropertyChanged, INotifyDataErrorInfo
{
    public RowViewModel()
    {
        _errorFromProperty = new Dictionary<string, string>
        {
            { nameof(Fee), null },
            { nameof(Amount), null },
        };

        PropertyChanged += OnPropertyChanged;
    }

    private void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        switch(e.PropertyName)
        {
            case nameof(Fee):
                OnFeePropertyChanged();
                break;
            case nameof(Amount):
                OnAmountPropertyChanged();
                break;
            default:
                break;
        }
    }

    private void OnFeePropertyChanged()
    {
        if (Fee == null)
            _errorFromProperty[nameof(Fee)] = "You must select a Fee!";
        else
            _errorFromProperty[nameof(Fee)] = null;

        NotifyPropertyChanged(nameof(Amount));
    }

    private void OnAmountPropertyChanged()
    {
        if (Fee == null)
            return;

        if (Amount < Fee.Min || Amount > Fee.Max)
            _errorFromProperty[nameof(Amount)] = $"Amount must be between {Fee.Min} and {Fee.Max}!";
        else
            _errorFromProperty[nameof(Amount)] = null;
    }

    public decimal Amount
    {
        get { return _Amount; }
        set
        {
            if (_Amount != value)
            {
                _Amount = value;
                NotifyPropertyChanged();
            }
        }
    }
    private decimal _Amount;

    public FeeType Fee
    {
        get { return _Fee; }
        set
        {
            if (_Fee != value)
            {
                _Fee = value;
                NotifyPropertyChanged();
            }
        }
    }
    private FeeType _Fee;

    #region INotifyPropertyChanged
    public event PropertyChangedEventHandler PropertyChanged;
    public void NotifyPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
    #endregion

    #region INotifyDataErrorInfo
    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

    public bool HasErrors
    {
        get
        {
            return _errorFromProperty.Values.Any(x => x != null);
        }
    }

    public IEnumerable GetErrors(string propertyName)
    {
        if (string.IsNullOrEmpty(propertyName))
            return _errorFromProperty.Values;

        else if (_errorFromProperty.ContainsKey(propertyName))
        {
            if (_errorFromProperty[propertyName] == null)
                return null;
            else
                return new[] { _errorFromProperty[propertyName] };
        }

        else
            return null;
    }

    private Dictionary<string, string> _errorFromProperty;
    #endregion
}

现在，我用 native 对其进行了测试DataGrid，但在 Telerik 中的结果应该是相同的：

<DataGrid AutoGenerateColumns="False" ItemsSource="{Binding Rows}">
  <DataGrid.Columns>
    <DataGridTextColumn Binding="{Binding Amount}"/>
    <DataGridComboBoxColumn SelectedItemBinding="{Binding Fee, UpdateSourceTrigger=PropertyChanged}"
                            ItemsSource="{x:Static local:FeeType.List}"
                            DisplayMemberPath="Name"
                            Width="200"/>
  </DataGrid.Columns>
</DataGrid>

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        Rows = new List<RowViewModel>
        {
            new RowViewModel(),
            new RowViewModel(),
        };

        DataContext = this;
    }

    public List<RowViewModel> Rows { get; } 
}

如果一个FeeType实例可以在运行时修改，您还需要在该类上实现Min，适当地处理值更改。MaxINotifyPropertyChanged

如果您对“MVVM”、“ViewModels”、“通知更改”等内容不熟悉，请查看这篇文章。如果你经常在 WPF 上做大中型项目，那么值得学习如何通过 MVVM 模式来解耦视图和逻辑。这使您能够以更快、更自动化的方式测试逻辑，并使事情保持井井有条并集中注意力。

于 2017-04-08T09:46:56.137 回答