## 引言

在之前写的一篇文章【[WPF --- 如何以Binding方式隐藏DataGrid列](https://niuery.com/post/87)】中，我先探索了 `DataGridTextColumn` 为什么不在可视化树结构内？又给出了解决方案，使用 `Freezable` ，该抽象类是 `DependencyObject` 的子类，能使用依赖属性在 `Xaml` 进行绑定，它承载了 `DataContext` 且有属性变化通知功能，触发 `VisibilityConverter`转换器，实现了预期功能。

然后有群友问了这样一个问题:

![6a4cc9fc16c64bdf43e471e8e5eede2.jpg](https://niuery.com/static/img/e6471aabc3a4f69aa31ca9378d3b431f.6a4cc9fc16c64bdf43e471e8e5eede2.jpg)

这里有两个问题：
1. 非可视化树中的元素不能通过 `RelativeSource` 或者 `ElementName` 访问到可视化树中的数据，为何可以通过 `resource` 的方式访问？
2. `Freezable` 类为何能够中转数据，`DependencyObject` 不行？


那么本篇文章就来探索一下 `Freezable`实现了上述功能的原理是什么？



## 原理探索

### 准备
我们还是使用上一篇文章中的示例，让后为了便于剖析源码，做了部分改动。

首先，准备自定义  `Freezable` 类：

```csharp
public class CustomFreezable : Freezable
{
    public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(object), typeof(CustomFreezable));

    public object Value
    {
        get => (object)GetValue(ValueProperty);
        set => SetValue(ValueProperty, value);
    }

    protected override void OnChanged()
    {
        base.OnChanged();
    }
    
    protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
    {
        base.OnPropertyChanged(e);
    }

    protected override Freezable CreateInstanceCore()
    {
        return new CustomFreezable();
    }
}
```
然后准备界面，但是这回跟之前不一样的是所有 `DataGridTextColumn` 列不在 XAML 中绑定，我们放在后台绑定:

```XML
<Window.Resources>
    <local:VisibilityConverter x:Key="VisibilityConverter" />
    <local:CustomFreezable x:Key="customFreezable" Value="{Binding IsVisibility, Converter={StaticResource VisibilityConverter}}" />
</Window.Resources>
<Grid>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="1*" />
            <ColumnDefinition Width="1*" />
        </Grid.ColumnDefinitions>
        <DataGrid
            x:Name="dataGrid"
            AutoGenerateColumns="False"
            CanUserAddRows="False"
            ItemsSource="{Binding Persons}"
            SelectionMode="Single">
        </DataGrid>
        <CheckBox
            Grid.Column="1"
            Content="是否显示年龄列"
            IsChecked="{Binding IsVisibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
    </Grid>
</Grid>

```

然后准备 `Code-Behind` 代码，增加 `InitDataGrid()` ，手动绑定所有列。


```csharp
public partial class MainWindow : Window, INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;

    public void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    public MainWindow()
    {
        InitializeComponent();
        Persons = new ObservableCollection<Person>() { new Person() { Age = 11, Name = "Peter" }, new Person() { Age = 19, Name = "Jack" } };
        DataContext = this;

        InitDataGrid();
    }

    private void InitDataGrid()
    {
        DataGridTextColumn columen1 = new DataGridTextColumn();
        columen1.Header = "年龄";
        columen1.Binding = new Binding("Age");
        columen1.Width = new DataGridLength(1, DataGridLengthUnitType.Star);

        Binding binding = new Binding("Value");
        binding.Source = FindResource("customFreezable");

        BindingOperations.SetBinding(columen1, DataGridTextColumn.VisibilityProperty, binding);

        dataGrid.Columns.Add(columen1);

        DataGridTextColumn columen2 = new DataGridTextColumn();
        columen2.Header = "姓名";
        columen2.Binding = new Binding("Name");
        columen2.Width = new DataGridLength(1, DataGridLengthUnitType.Star);

        dataGrid.Columns.Add(columen2);

    }

    private bool isVisibility = true;
    public bool IsVisibility
    {
        get => isVisibility;
        set
        {
            isVisibility = value;
            OnPropertyChanged(nameof(IsVisibility));
        }
    }

    private ObservableCollection<Person> persons;

    public ObservableCollection<Person> Persons
    {
        get { return persons; }
        set { persons = value; OnPropertyChanged(); }
    }
}
```

### 源码剖析

在源码剖析之前，如果大家还不会如何使用VS调试.Net源码，建议先阅读我的另一篇文章【[编程技巧 --- VS如何调试.Net源码](https://niuery.com/post/88)】，学习如何调试源码。
 
 
接下来，在程序启动之前，我们在 `CustomFreezable` 的重载方法 `OnChanged()` 设置断点，然后使用VS调试源码，查看调用堆栈：

![image.png](https://niuery.com/static/img/f59f606cfb7b26d64ad3a15faaea05bd.image.png)

可以看到，从 `InitDataGrid()` 开始，到属性变化触发变化事件，整个流程都可以在调用堆栈中看到，我们可以逐帧分析，来解决开篇的两个问题。

### 剖析步骤
我们将上述调用链编号，逐步分析：

![96913be89dae64b14049a1bf366ef53.png](https://niuery.com/static/img/e7dd19cb44cad105227953dfc7941847.96913be89dae64b14049a1bf366ef53.png)

1. 编号1：FindResource(...)

![1.png](https://niuery.com/static/img/e2643ef76a4ce4e6e0ec8c2390c58c68.1.png)

2. 编号2：FrameworkElement.FindResourceInternal(...)

![2.png](https://niuery.com/static/img/31f34242b0a8f749509acd4e88b1073d.2.png)

3. 编号3：FindResourceInTree(...)

![3.png](https://niuery.com/static/img/b036784e072af34df42bfad97d978d44.3.png)

4. 编号4：FetchResource(...)

![4.png](https://niuery.com/static/img/a516ae26fc6cb5e32e0e4106c76c6c51.4.png)

5. 编号5~6：GetValue(...)，在这里已经获取到字典中资源了。 

![5.png](https://niuery.com/static/img/29341fe360cd64a563ccad61b065b03e.5.png)

6. 编号7~8 OnGettingValue(...)

![6.png](https://niuery.com/static/img/d0189ef0f7c0a86194d189185d127510.6.png)

7. 编号9~10 AddInheritanceContext(...)

![7.png](https://niuery.com/static/img/2b31eafc47b0866c7362a1c6ff1edc99.7.png)

8. 编号11~12 ProvideSelfAsInheritanceContext(...)
![8.png](https://niuery.com/static/img/dfd435f5ac0212eb25ac203581f1bb3f.8.png)

9. 编号13  AddInheritanceContext(...)
![9.png](https://niuery.com/static/img/b1199688dcf145fcb8d23e87408a0690.9.png)
![11.png](https://niuery.com/static/img/4479db30fb91acbd18cf869ba51b3084.11.png)

后面的就不用看了，后面的就是因为 `Freezable` 更换了 `InheritanceContext` 触发了`OnInheritanceContextChanged()`后又触发了 `NotifyPropertyChange`。

接下来看看为什么当 `IsVisibility` 变化时，能通知到  `Freezable`？

10. NotifySubPropertyChange(...)

![12.png](https://niuery.com/static/img/b602c0142cbbf6ba05793badbaa3538c.12.png)

11. FireChanged(...)

![13.png](https://niuery.com/static/img/ebcf7b2eea695a29e781139de57fec8d.13.png)

12. GetChangeHandlersAndInvalidateSubProperties(...)
![14.png](https://niuery.com/static/img/196543b7c09d0e19f3404d27516cefbd.14.png)


可以看到从1\~9仅仅是 ` FindResource("customFreezable"); ` 这一个方法所作的事情，主要是从资源字典中查询想要的对象，如果该对象是 `Freezable`类型的，则将当前资源的 `DataContent`的 `Visual` 绑定为 `Freezable`的 `InheritanceContext` ，然后10\~12，是该上下文在当前资源的 `DataCobtent` 触发 `PropertyChanged`时，去`InheritanceContext` 中找出关联的 `CallHandle` 强制刷新，触发变化事件，达到联动效果。

那么从解析源码的过程中看，开篇的两个问题就都有了答案
1. 非可视化树中的元素不能通过 `RelativeSource` 或者 `ElementName` 访问到可视化树中的数据，为何可以通过 `resource` 的方式访问？

    原因就是 `FindResource` 方法中，如果要查询的资源是`Freezable`类型的，则会将当前资源的 `DataContent`的 `Visual` 绑定到 `InheritanceContext`，所以`Freezable` 也就可以访问到可视化树中的数据了。

2. `Freezable` 类为何能够中转数据，`DependencyObject` 不行？
 
   从代码中，编号11\~12 ProvideSelfAsInheritanceContext(...)也可以看出，绑定 `InheritanceContext` 时有一个必要条件就是该资源必须为 `Freezable` 类型的才可以，我猜测这可能跟这个类的定义有关系，`Freezable` 类为 `WPF` 中的对象提供了不可变性和性能优化的功能，同时也为动画、资源共享和跨线程安全性等方面提供了便利。 该类是更好地管理和优化 WPF 应用程序中的对象和资源的，所以可能不想让开发者随意使用吧，所以就仅提供该类能够拥有 `InheritanceContext` 而没法使用 `DependencyObject` 。

## 小结

`Freezable` 类除了上文示例中的用法，其实它这种间接绑定的方式可以解决很多场景，比如某个元素的属性并不是依赖属性，但是你就是想使用 `Binding` 的方式，让它动态变化，也可以使用上文示例的方式进行绑定。

好了，源码解析的过程其实还是比较复杂的，本文中其实也省略了一些源码阅读过程中细节，若大家阅读有疑问的地方，欢迎找我解疑，建议不明白的点，优先自行进行一下源码调试。

Freezable ---探索Freezable承载数据的原理

## 引言

如题，在VS中如何调试 .Net 源码呢？

一般来说，VS2022，都是默认启用 F12 转到定义能够看到源码，如果大家发现自己无法使用 F12 查看源码，可以在 "工具" -> "选项" -> "文本编辑器" -> "C#" -> "高级" -> "转到定义"，勾选所有选项就对了。

![image.png](https://niuery.com/static/img/3c0b131c0d6e6631e8a89611956e6fac.image.png)

但是光以上的操作还是不够的，这样的可以查看源码中类型和成员的声明，但不能看到其实现。
比如，在WPF中，`Code-Behind` 中使用 `FindResource()` 查找资源，那我们直接 F12 转到定义，则像这样：
![image.png](https://niuery.com/static/img/a686eefb1769368d4e69cd8f492a2309.image.png)

我们仅能看到他是 `FrameworkElement` 类型下的一个方法。并没有具体实现。
## 示例
那我们怎么看它的具体实现呢？

首先，我们需要有对应的配置，那就是需要启用源代码单步执行。
1. 在"工具"（或"调试"） -> "选项" -> "调试" -> "常规"下，确保：
     - 取消选择"启用仅我的代码"。
     - 选择"启用源链接支持"。
2. 在"工具"（或“调试”） -> "选项" -> "调试" -> "符号"下，选择"Microsoft 符号服务器"。

![image.png](https://niuery.com/static/img/63337b5a08e5680e2a688591e6f0c6c2.image.png)


![image.png](https://niuery.com/static/img/598a722eff5aa47485d5ddc4a5aa1e9c.image.png)

这样配置完之后，我们就可以使用"调用堆栈"窗口下载和加载符号进行源码调试。

这里需要注意，当你配置完上述设置后，第一次启动应用会有较长的一段符号加载的时间，耐心等待。

![image.png](https://niuery.com/static/img/30fb808fd0b8d4709f01ef1a8abca9d0.image.png)
### 准备
首先新建一个WPF项目，窗体中放置一个“测试按钮”，然后创建一个 `Button` 的 `style`，像这样：

```xml
<Window.Resources>
    <Style x:Key="buttonStyle" TargetType="Button">
        <Setter Property="Background" Value="Red" />
        <Setter Property="FontSize" Value="22" />
        <Setter Property="Foreground" Value="Yellow" />
    </Style>
</Window.Resources>
<Grid>
    <Button
        x:Name="button"
        Width="200"
        Height="80"
        HorizontalAlignment="Center"
        VerticalAlignment="Center"
        Content="测试按钮"/>
</Grid>
```
然后，我们主窗体的 `Loaded` 事件中通过 `FindResource()` 来给这个按钮绑定样式，如下：

```csharp
private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
   button.Style = FindResource("buttonStyle") as Style; 
} 
```


### 调试

接下来调试就很简单了，我们在 `Loaded` 事件中打断点，命中断点后，我们就可以直接通过 F11 进入 `FindResource()` 的源码方法体中了，如下：

![image.png](https://niuery.com/static/img/059819efe0a1df4685e30debb5d3309b.image.png)

从图中也可以看出，它是可以进行单步调试的，且也能获取到上下文或参数的值。

## 小结

本文讲解了如何通过 VS2022 调试 .Net 源码，学会源码调试，是一项强有力的技能。

通过调试源码，可以逐步跟踪代码的执行流程，观察数据的变化，更直观地理解代码的运行方式，深入理解框架工作原理。

更重要的是通过它分析问题根源，在调试过程中，你可以找到问题的根源，比如变量的状态、方法的调用流程等，提升我们解决BUG的效率。

建议大家动手实践，提升自己的调试技巧。


>参考链接
>
>https://learn.microsoft.com/zh-cn/visualstudio/debugger/how-to-debug-dotnet-framework-source?view=vs-2022

编程技巧 --- VS如何调试.Net源码

## 引言

如题，如何以Binding的方式动态隐藏DataGrid列？


## 预想方案
像这样：

先在ViewModel创建数据源 `People` 和控制列隐藏的 `IsVisibility`，这里直接以 `MainWindow` 为 `DataContext`

```csharp
 public partial class MainWindow : Window, INotifyPropertyChanged
 {
     public MainWindow()
     {
         InitializeComponent();
         Persons = new ObservableCollection<Person>() { new Person() { Age = 11, Name = "Peter" }, new Person() { Age = 19, Name = "Jack" } };
         DataContext = this;
     }

     public event PropertyChangedEventHandler? PropertyChanged;

     public void OnPropertyChanged([CallerMemberName] string propertyName = null)
     {
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }


     private bool isVisibility;
     
     public bool IsVisibility
     {
         get => isVisibility;
         set
         {
             isVisibility = value;
             OnPropertyChanged(nameof(IsVisibility));
         }
     }

     private ObservableCollection<Person> persons;

     public ObservableCollection<Person> Persons
     {
         get { return persons; }
         set { persons = value; OnPropertyChanged(); }
     }
 }

```
然后创建 `VisibilityConverter`，将布尔值转化为 `Visibility`。
```csharp
 public class VisibilityConverter : IValueConverter
 {
     public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
     {
         if (value is bool isVisible && isVisible)
         {
             return Visibility.Visible;
         }
         return Visibility.Collapsed;
     }

     public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
     {
         throw new NotImplementedException();
     }
 }
```
然后再界面绑定 `IsVisibility`，且使用转化器转化为`Visibility`，最后增加一个 `CheckBox` 控制是否隐藏列。

```xml

<Grid>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="1*" />
            <ColumnDefinition Width="1*" />
        </Grid.ColumnDefinitions>
        <DataGrid
            x:Name="dataGrid"
            AutoGenerateColumns="False"
            CanUserAddRows="False"
            ItemsSource="{Binding Persons}"
            SelectionMode="Single">
            <DataGrid.Columns>
                <DataGridTextColumn
                    Header="年龄"                
                    Width="*"
                    Binding="{Binding Age}"
                    Visibility="{Binding DataContext.IsVisibility, RelativeSource={RelativeSource Mode=FindAncestor, AncestorLevel=1, AncestorType={x:Type Window}}, Converter={StaticResource VisibilityConverter}}" />
                <DataGridTextColumn Header="姓名" Width="*" Binding="{Binding Name}" />
            </DataGrid.Columns>
        </DataGrid>
        <CheckBox
            Grid.Column="1"
            Content="是否显示年龄列"
            IsChecked="{Binding IsVisibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
    </Grid>
</Grid>

```
这样应该没问题，`Visibility` 是依赖属性，能直接通过 Binding 的方式赋值。

但实际测试时就会发现，勾选 `CheckBox` 能够改变 `DataContext.IsVisibility` 的值，但是无法触发转换器 `VisibilityConverter`，即使不用 `RelativeSource` 方式，更改为指定 `ElementName`获取元素的方式，也一样不生效。

这是为什么呢？

我疑惑了很久，直到看到了Visual Studio中的实时可视化树：

![image.png](https://niuery.com/static/img/f2f0f5ad81276b710bdbb2db0b82741e.image.png)

从图中可以看出，虽然我在 Xaml 中声明了两列 `DataGridTextColumn`，但他根本不在可视化树中。

**获取 `RelativeSource` 和指定 `ElementName` 的方式，本质上还是在可视化树中寻找元素**，所以上述方案无法生效。

那为什么 `DataGridTextColumn` 不在可视化树中呢？

## 可视化树（Visula Tree）

在上面那个问题之前，先看看什么是可视化树？

我们先从微软文档来看一下WPF中其他控件的继承树。

比如  `Button`

![image.png](https://niuery.com/static/img/c55be1eb8934e940d2846b4018bb6c31.image.png)

比如 `DataGrid` ：

![image.png](https://niuery.com/static/img/5c0d90ad8fa2fb0c88876d33b7d4e97c.image.png)

又比如 `ListBox` ：

![image.png](https://niuery.com/static/img/4e7a3ecedc359a22651d2523990de485.image.png)


大家可以去看看其他的控件，几乎 WPF 中所有的控件都继承自 `Visual`（例如，`Panel`、`Window`、`Button` 等都是由 `Visual` 对象构建而成）。

`Visual` 是 WPF 中可视化对象模型的基础，而 `Visual` 对象通过形成可视化树（`Visual Tree`）来组织所有可视化模型。所以`Visual Tree` 是一个层次结构，包含了所有界面元素的视觉表示。**所有继承自 `Visual` 或 `UIElement`（UI 元素的更高级别抽象）的对象都存在于可视化树中。**

但是，`DataGridColumn` 是一个特例，它不继承 `Visual`，它直接继承 `DependencyObject`，如下：

![image.png](https://niuery.com/static/img/688bd08251a6adb16c8479fdcf0e29c3.image.png)

所以，`DataGridColumn`的继承树就解答了他为什么不在可视化树中。

## 解决方案

所以，通过直接找 `DataContext` 的方式，是不可行的，那就曲线救国。

既然无法找到承载 `DataContext.IsVisibility` 的对象，那就创建一个能够承载的对象。首先该对象必须是 `DependencyObject` 类型或其子类，这样才能使用依赖属性在 `Xaml` 进行绑定，其次必须有属性变化通知功能，这样才能触发 `VisibilityConverter`，实现预期功能。

这时候就需要借助一个抽象类 `System.Windows.Freezable`。摘取部分官方解释如下：

![image.png](https://niuery.com/static/img/7a374c4a2f0276d1382bfca1fd46887d.image.png)
![image.png](https://niuery.com/static/img/c40bbb8b2c8de15d6861c56293d542da.image.png)

从文档中可以看出 `Freezable` 非常符合我们想要的，第一它本身继承 `DependencyObject` 且 它在子属性值更改时能够提供变化通知。

所以我们可以创建一个自定义 `Freezable` 类，实现我们的功能，如下：

```csharp
public class CustomFreezable : Freezable
{
    public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(object), typeof(CustomFreezable));

    public object Value
    {
        get => (object)GetValue(ValueProperty);
        set => SetValue(ValueProperty, value);
    }

    protected override void OnChanged()
    {
        base.OnChanged();
    }
    
    protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
    {
        base.OnPropertyChanged(e);
    }

    protected override Freezable CreateInstanceCore()
    {
        return new CustomFreezable();
    }
}

```

然后在 `Xaml` 添加 `customFreezable` 资源，给 `DataGridTextColumn` 的 `Visibility` 绑定资源

```xml
<Window.Resources>
    <local:VisibilityConverter x:Key="VisibilityConverter" />
    <local:CustomFreezable x:Key="customFreezable" Value="{Binding IsVisibility, Converter={StaticResource VisibilityConverter}}" />
</Window.Resources>
<Grid>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="1*" />
            <ColumnDefinition Width="1*" />
        </Grid.ColumnDefinitions>
        <DataGrid
            x:Name="dataGrid"
            AutoGenerateColumns="False"
            CanUserAddRows="False"
            ItemsSource="{Binding Persons}"
            SelectionMode="Single">
            <DataGrid.Columns>
                <DataGridTextColumn
                    x:Name="personName"
                    Width="*"
                    Binding="{Binding Age}"
                    Header="年龄"
                    Visibility="{Binding Value, Source={StaticResource customFreezable}}" />
                <DataGridTextColumn
                    Width="*"
                    Binding="{Binding Name}"
                    Header="姓名" />
            </DataGrid.Columns>
        </DataGrid>
        <CheckBox
            Grid.Column="1"
            Content="是否显示年龄列"
            IsChecked="{Binding IsVisibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
    </Grid>
</Grid>

```

测试：

勾选后，显示年龄列：
![image.png](https://niuery.com/static/img/22e0991fd50b4a61acc62a21491c1a71.image.png)

取消勾选后，隐藏年龄列
![image.png](https://niuery.com/static/img/a198006f146c64dcbacc9fa31261cbc6.image.png)

## 小结

本篇文章中，首先探索了 `DataGridTextColumn` 为什么不在可视化树结构内，是因为**所有继承自 `Visual` 或 `UIElement`（UI 元素的更高级别抽象）的对象才存在于可视化树中。**，`DataGridTextColumn`是直接继承`DependencyObject` ，所以才不在可视化树结构内。

其次探索如何通过曲线救国，实现以 `Binding` 的方式实现隐藏`DataGridTextColumn`，我们借助了一个核心抽象类  `System.Windows.Freezable`。该抽象类是 `DependencyObject` 的子类，能使用依赖属性在 `Xaml` 进行绑定，且有属性变化通知功能，触发 `VisibilityConverter`转换器，实现了预期功能。

如果大家有更优雅的方案，欢迎留言讨论。

>参考
>
> stackoverflow - how to hide wpf datagrid columns depending on a propert?: https://stackoverflow.com/questions/6857780/how-to-hide-wpf-datagrid-columns-depending-on-a-property
>
> Freezable Objects Overview： https://learn.microsoft.com/zh-cn/dotnet/desktop/wpf/advanced/freezable-objects-overview?view=netframeworkdesktop-4.8&wt.mc_id=MVP

WPF --- 如何以Binding方式隐藏DataGrid列

Git --- Git使用手册

## 引言
在WPF应用程序开发中，数据校验是确保用户输入数据的正确性和完整性的重要一环。

之前在做一些参数配置功能时，最是头疼各种参数校验，查阅一些资料后，我总结了数据校验方式有两种：
- ValidationRule
- IDataErrorInfo

接下来分别介绍这两种校验方式。



## ValidationRule
`ValidationRule` 是一个抽象类，提供了抽象方法 `Validate()`, 它是WPF中用于数据验证的一种机制，它可以在用户输入数据之前或之后执行自定义的验证逻辑。可以轻松地实现对数据的格式、范围、逻辑等方面的验证，并在验证失败时提供相应的反馈信息。

**ValidationRule主要作用域在前端页面上**。

### 基本用法
首先创建一个 `ValidationRule`，我这里设定了两个属性 `MaxVal`、`MinVal`，然后在 `Validate()` 方法中判断空、判断大于上限或小于下限，然后在符合条件是，返回 `ValidationResult`，并给出错误提示：


```csharp
public class IntegerValidationRule : ValidationRule
{
    public int MaxVal { get; set; }
    public int MinVal { get; set; }

    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        string text = value as string;

        if (!int.TryParse(text, out int result))
        {
            return new ValidationResult(false, "Text cannot be empty.");
        }

        if (result > MaxVal)
        {
            return new ValidationResult(false, "Value out of upper limit range.");
        }

        if (result < MinVal)
        {
            return new ValidationResult(false, "Value out of lower limit range.");
        }

        return ValidationResult.ValidResult;
    }
}

```
接下来创建有个测试使用的 `ViewModel`:


```csharp
public class TestViewModel : INotifyPropertyChanged
{
    private TestViewModel() { }

    public static TestViewModel Instance { get; } = new TestViewModel();

    public event PropertyChangedEventHandler? PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    private int testField1;
    /// <summary>
    /// 测试属性1
    /// </summary>
    public int TestField1
    {
        get => testField1;
        set
        {
            testField1 = value;
            OnPropertyChanged(nameof(TestField1));
        }
    }

    private int testField2;
    /// <summary>
    /// 测试属性2
    /// </summary>
    public int TestField2
    {
        get => testField2;
        set
        {
            testField2 = value;
            OnPropertyChanged(nameof(TestField2));
        }
    }
}


```

在测试之前，我们可以先看一下 `Binding` 的方法列表：

![image.png](https://niuery.com/static/img/43c3f9b39971e4debca27425dcc06916.image.png)

可以看到 **`ValidationRules` 是 `Binding` 下的集合，这意味着 `ValidationRule` 是在 `Binding` 下使用且可以执行多个校验规则。校验时按照顺序依次校验。**

接下来我们创建一个WPF应用程序，在界面添加 `TextBox`，命名为”textbox1“,将文本绑定在 `TestViewModel` 的 `TestField1`。

且为`Validation.ErrorTemplate` 绑定一个模板，这里绑定了一个红色的感叹号。

然后为 `TextBox` 设置触发器，当 `Validation.HasError`为 `true`时，将 `ToolTip` 绑定校验失败的错误提示。

代码如下：

```xml
<Window
    x:Class="WpfApp4.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:local="clr-namespace:WpfApp4"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    Title="MainWindow"
    Width="900"
    Height="450"
    mc:Ignorable="d">
    <Window.Resources>
        <ControlTemplate x:Key="ValidationTemplate">
            <DockPanel>
                <TextBlock
                    Margin="-10,0,0,0"
                    VerticalAlignment="Center"
                    FontSize="22"
                    Foreground="Red"
                    Text="!" />

            </DockPanel>
        </ControlTemplate>

        <Style TargetType="TextBox">
            <Style.Triggers>
                <Trigger Property="Validation.HasError" Value="true">
                    <Setter Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self}, Path=(Validation.Errors)[0].ErrorContent}" />
                </Trigger>
            </Style.Triggers>
        </Style>
    </Window.Resources>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="1*" />
            <ColumnDefinition Width="1*" />
        </Grid.ColumnDefinitions>
        <StackPanel Grid.Column="0">
            <TextBlock
                HorizontalAlignment="Center"
                FontSize="18"
                FontWeight="Bold"
                Text="Validation Demo" />
            <TextBox
                Name="textBox1"
                Height="30"
                Margin="10"
                FontSize="22"
                Validation.ErrorTemplate="{StaticResource ValidationTemplate}">
                <TextBox.Text>
                    <Binding Path="TestField1" UpdateSourceTrigger="PropertyChanged">
                        <Binding.ValidationRules>
                            <local:IntegerValidationRule
                                MaxVal="999"
                                MinVal="5" />
                        </Binding.ValidationRules>
                    </Binding>
                </TextBox.Text>
            </TextBox>

        </StackPanel>
    </Grid>
</Window>

```
最后在窗体后台绑定 `ViewModel`:

```csharp
public MainWindow()
{
    InitializeComponent();
    this.DataContext =  TestViewModel.Instance;
}

```
### 测试

1. 为空时，出现红色叹号，`ToolTip` 提示 "Text cannot be empty."
![image.png](https://niuery.com/static/img/3dc5e4c153b087fc36f5ddcfb1e664fe.image.png)

2. 小于下限时，出现红色叹号，`ToolTip` 提示 "Value out of lower limit range."
![image.png](https://niuery.com/static/img/88d90b70aac9d55b46d151e4b5d0fdc8.image.png)

3. 大于上限时，出现红色叹号，`ToolTip` 提示 "Value out of upper limit range."
![image.png](https://niuery.com/static/img/762b62259b10fb28617ee49276105ca4.image.png)
## IDataErrorInfo

`IDataErrorInfo` 是一个接口，Viewmodel 实现接口用于在后台，提供数据验证和错误信息。

`IDataErrorInfo` 主要作用域为后台 `ViewModel`
该接口包含两个成员：`Error` 和 `this[string columnName]`。这两个成员允许你在数据绑定时提供验证错误信息。

### 基本用法

接下来，在程序里添加 `TextBox`，命名为”textbox2“，并添加一个 `TextBlock` 绑定 `Error` 展示在界面。
```xml
<StackPanel Grid.Column="1">
    <TextBlock
        HorizontalAlignment="Center"
        FontSize="18"
        FontWeight="Bold"
        Text="IDataErrorInfo Demo" />
    <TextBox
        Name="textBox2"
        Margin="10"
        VerticalAlignment="Center"
        FontSize="22"
        Text="{Binding TestField2, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
     <TextBlock
         HorizontalAlignment="Center"
         FontSize="18"
         FontWeight="Bold"
         Foreground="Red"
         Text="{Binding Error, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
</StackPanel>
```

后台 `TestViweModel` 实现 `IDataErrorInfo`，依旧是判断上限值和下限值，此处不判断空，是因为后台 `TestField2` 类型是Int，为空时不会赋值，代码如下：

```csharp
public class TestViewModel : INotifyPropertyChanged, IDataErrorInfo
{
    //省略上文已有代码..。
    
    private string error;
    public string Error
    {
        get => error;
        set
        {
            error = value; OnPropertyChanged(nameof(Error));
        }
    }
    public string this[string columnName]
    {
        get
        {
            switch (columnName)
            {
                case nameof(TestField2):
                    return CheckTestFild2();
                default:
                    return null;
            }
        }
    }

    public int MaxVal = 999;
    public int MinVal = 5;

    private string CheckTestFild2()
    {
        if (TestField2 > MaxVal)
        {
            Error = "Value out of upper limit range in viewmodel.";
        }
        else if (TestField2 < MinVal)
        {
            Error = "Value out of lower limit range  in viewmodel.";
        }
        else
        {
            Error = string.Empty;
        }
        
        return Error;
    }
}
```
### 测试

1. 小于下限时，出现红色文字提示，`ToolTip` 提示 "Value out of lower limit range in viewmodel."
![image.png](https://niuery.com/static/img/2ba46191051264fd5998ce38c0c23e9d.image.png)

2. 大于上限时，出现红色文字提示，`ToolTip` 提示 "Value out of upper limit range in viewmodel."
![image.png](https://niuery.com/static/img/54e898c947d977e9e9c686bae9a1230b.image.png)

## 小结

以上两种数据校验（`IDataErrorInfo`、`ValidationRule`）的方式，均可以实现自定义数据校验，例如对数据的格式、范围、逻辑等方面的验证，并在验证失败时提供相应的反馈信息。

`ValidationRule`适用于在界面做数据校验，且可以定义多个校验规则。

`ValidationRule`适用于在ViewModel做数据校验，可以做一些无法在前端页面做的事情，比如出现异常值是还原为默认值。

所以两者既可以单独使用，也可以组合使用，即使使用MVVM模式，依旧能够优雅的做数据校验。

引言

引言

引言

git是什么

引言