世界上存在成千上万种学习法，如果上天只让我掌握一种，那一定就是“费曼学习法”。


## 介绍
费曼学习法是由诺贝尔物理学奖获得者理查德·费曼提出的一种学习方法，其核心思想是将所学内容用自己的话表达出来，以此检验自己对知识的掌握程度。

费曼学习法可以简化为四个单词：**Concept**、**Teach**、**Review**、**Simplify**

具体而言，费曼学习法包括以下几个步骤：

- **Concept**：选择一个主题，并尽可能全面地了解这个主题；

- **Teach**：将所学内容以简明易懂的语言写下来或讲述给别人听，使用通俗易懂的语言和例子，避免使用学术术语和复杂的句子；

- **Review**：检查自己的表达是否清晰明了，是否有遗漏或错误；

- **Simplify**：基于反馈修正自己的表达，直到能够清晰表达该主题。

其优点是：

- 突出重点：在解释一个概念时，我们不得不选取最重要的信息，并将其用自己的话表达出来。这种方式可以帮助我们更好地理解和记忆知识点。

- 发现问题：当我们尝试用自己的话阐述某个主题时，常常会发现自己对某些内容并不理解或者存在疑问。这种方式可以帮助我们及时发现自己的盲点和问题，促进深层次的学习。

- 加深印象：通过不断反复的讲解和修正，我们能够形成对于某个主题的深层次理解，并加深对于相关概念的印象。

## 数据

美国学术界在1946年一项研究显示了不同学习方式的效益，准确的说，是学习者在两周以后还能记住内容（平均学习保持率）的多少。

下图是当时美国教育学家Engar Dale研究出的“学习金字塔”（The Cone of Learning）。

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

由上图可以看出，**Learning by teaching 可以说是学习效率最高的方式**。

Learning by teaching --- 费曼学习法

## 引言
软件开发过程中，我们经常会遇到各种设计问题，例如如何管理对象之间的关系、如何优化代码的可复用性和可维护性等等。为了解决这些问题，我们可以使用设计模式。



设计模式是一种被广泛接受的软件设计思想，它提供了一套通用的解决方案，可以帮助我们更好地解决常见的软件设计问题。设计模式是从实践中总结出来的，它不仅可以提高代码的可读性和可维护性，还可以提高开发效率和代码的可复用性。

## 常见设计模式原则
设计模式有常见的五大原则 - [SOLID](https://niuery.com/post/9)
- 单一职责原则（SRP）
- 开放封闭原则（OCP）
- 里氏替换原则（LSP）
- 接口隔离原则（DIP）
- 依赖倒置原则（ISP）


补充第六原则，迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)

## 常见设计模式类型
- 创建型模式：负责对象的创建和初始化，共有5种：**工厂方法模式**、**抽象工厂模式**、**单例模式**、**建造者模式**、**原型模式**。
- 结构型模式：负责对象的组合，共有7种：**适配器模式**、**装饰器模式**、**代理模式**、**外观模式**、**桥接模式**、**组合模式**、**享元模式**。
- 行为型模式：负责对象之间的通信，共有11种：**观察者模式**、**策略模式**、**迭代器模式**、**命令模式**、**责任链模式**、**模板方法模式**、**访问者模式**、**中介者模式**、**解释器模式**、**过滤器模式**、**备忘录模式**。
## 目录

### 创建型模式

1. [**抽象工厂模式（Abstract Factory Pattern）**](https://niuery.com/post/10)

抽象工厂模式是一种创建型设计模式，它提供了一种封装一组相关或相互依赖对象创建过程的方法，使得我们可以在不知道具体实现细节的情况下，创建一系列相互协作的对象。

2. [**工厂方法模式（Factory Method Pattern）**](https://niuery.com/post/33)

工厂方法模式是一种创建型设计模式，它提供了一种将对象的创建过程封装起来的方法，使得我们可以在不知道具体实现细节的情况下，创建各种不同类型的对象。

3. [**单例模式（Singleton Pattern）**](https://niuery.com/post/11)

单例模式是一种保证一个类只有一个实例的模式，它可以避免多个实例造成的资源浪费和对象的不一致性。单例模式通常使用一个私有的构造函数和一个静态的实例变量来实现。

4. [**建造者模式（Builder Pattern）**](https://niuery.com/post/13)

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式可以将复杂对象的构建过程抽象出来，从而使得系统更加灵活。

5. [**原型模式（Prototype Pattern）**](https://niuery.com/post/14)

用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象。原型模式可以在运行时动态地创建对象，从而避免了静态工厂方法所带来的编译时耦合。


### 结构型模式
1. [**适配器模式（Adapter Pattern）**](https://niuery.com/post/15)

适配器模式是一种将一个类的接口转换成客户端所期望的另一种接口的模式，它可以让原本不兼容的类能够协同工作。这种模式可以避免因接口不匹配而导致的代码重构和重复开发。

2. [**装饰器模式（Decorator Pattern）**](https://niuery.com/post/16)

装饰器模式是一种在运行时动态地给对象添加新的功能的模式，它通过将对象包装在一个装饰器中来实现。这种模式可以避免使用继承带来的复杂性和静态特性，提高代码的灵活性和可扩展性。

3. [**代理模式（Proxy Pattern）**](https://niuery.com/post/17)

代理模式是一种结构型设计模式，它允许我们创建一个代理对象来控制对另一个对象的访问。代理对象可以充当原始对象的访问接口，从而控制对原始对象的访问。代理模式通常用于远程访问、延迟加载、访问控制等方面。

4. [**外观模式（Facade Pattern）**](https://niuery.com/post/18)

为一组复杂的子系统提供一个简单的接口，从而隐藏子系统的复杂性。外观模式可以降低客户端和子系统之间的耦合度，同时提高客户端的易用性。

5. [**桥接模式（Bridge Pattern）**](https://niuery.com/post/19)

桥接模式是一种将抽象部分与它的实现部分分离开来的模式，使它们可以独立地变化。这种模式可以避免因为实现细节的变化而导致的代码修改和重构。

6. [**组合模式（Composite Pattern）**](https://niuery.com/post/20)

组合模式是一种将对象组合成树形结构的模式，使得客户端可以像处理单个对象一样处理对象的组合。这种模式可以使得对象之间的关系更加清晰，提高代码的可读性和可维护性。

7. [**享元模式（Flyweight Pattern）**](https://niuery.com/post/21)

享元模式是一种结构型设计模式，用于优化对象的创建和使用。该模式通过共享相同的数据，来减少内存的使用和对象的创建。通常情况下，享元模式适用于存在大量相似对象的情况

### 行为型模式

1. [**观察者模式（Observer Pattern）**](https://niuery.com/post/12)

观察者模式是一种对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。这种模式可以降低对象之间的耦合度，提高系统的灵活性和可扩展性。

2. [**策略模式（Strategy Pattern）**](https://niuery.com/post/22)

策略模式是一种定义一系列算法的模式，它将每个算法封装在一个类中，并使它们可以互相替换。这种模式可以避免使用大量的条件语句和重复代码，提高代码的可维护性和可扩展性。

3. [**迭代器模式（Iterator Pattern）**](https://niuery.com/post/23)

迭代器模式是一种访问一个聚合对象中的各个元素的方式，而又不需要暴露该对象的内部表示。这种模式可以让客户端透明地访问聚合对象中的元素，同时避免了聚合对象的数据结构对客户端的依赖。

4. [**命令模式（Command Pattern）**](https://niuery.com/post/25)

将请求封装成对象，从而使不同的请求可以被不同的对象处理。命令模式可以将请求的发送者和接收者解耦，同时支持请求的撤销和重做

5. [**责任链模式（Chain of Responsibility Pattern）**](https://niuery.com/post/26)

将请求的发送者和接收者解耦，通过一条由多个处理对象组成的链来处理请求。责任链模式可以根据需求动态地组合处理对象，从而实现请求的自动转发和处理。

6. [**模板方法模式（Template Method Pattern）**](https://niuery.com/post/27)

定义一个操作中的算法骨架，将一些步骤延迟到子类中。模板方法模式可以提高代码的复用性和可维护性，同时可以避免子类中的代码重复

7. [**状态模式（State Pattern）**](https://niuery.com/post/28)

允许对象在内部状态发生改变时改变它的行为。状态模式将对象的行为和状态进行分离，从而将复杂的条件判断转化为简单的状态切换。

8. [**中介者模式（Mediator Pattern）**](https://niuery.com/post/29)

用一个中介对象来封装一系列的对象交互，从而使对象之间的交互松散耦合。中介者模式可以简化对象之间的交互，同时降低对象之间的依赖关系。

9. [**解释器模式（Interpreter Pattern）**](https://niuery.com/post/30)

给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。解释器模式可以将复杂的语言转化为易于处理的数据结构，从而使得语言的解释更加容易。

10. [**访问者模式（Visitor Pattern）**](https://niuery.com/post/31)

访问者模式是一种行为设计模式，它可以让你将算法与它们操作的对象分离。这样，你可以在不修改对象结构的情况下，向现有的对象结构添加新的操作。

11. [**备忘录模式（Memento Pattern）**](https://niuery.com/post/32)
备忘录模式是一种行为型设计模式，它允许我们将对象的状态保存在备忘录对象中，从而可以在以后恢复对象的状态。该模式通常用于需要撤销、恢复操作的场景，例如文本编辑器、绘图应用等。备忘录模式通过将状态保存在备忘录对象中来实现状态的恢复，从而保证了对象的封装性和数据安全性。

> 参考资料
> 
> https://dofactory.com/net/abstract-factory-design-pattern
> 
> https://refactoring.guru/design-patterns

重温设计模式 --- 前篇

## 引言

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

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

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

那么本篇文章就来探索两个问题：
- 第一个问题，为什么可以通过 `Resource` 的方式可以访问 `Freezable` 中的 `DataContext`?
- 第二个问题，为什么`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();
    }
}
```
然后准备界面，但是这回跟之前不一样的是所有 `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()` 开始，到属性变化触发变化事件，整个流程都可以在调用堆栈中看到，我们可以逐帧分析，来解决开篇的两个问题。

#### 问题1

第一个问题，为什么可以通过 `Resource` 的方式可以访问 `Freezable` 中的 `DataContext`?

上述代码中，我们将本应该在界面绑定的 `Visibility`，放在后台绑定。

```xml
<DataGridTextColumn
    x:Name="personName"
    Header="年龄"
    Width="*"
    Binding="{Binding Age}"
    Visibility="{Binding Value, Source={StaticResource customFreezable}}" />
```
转换成了 `Code-Behind`

```csharp
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);
```

所以重点看一下方法`FindResource()`到做了什么，根据上图的调用堆栈先列一下调用链 



#### 问题2

第二个问题，为什么`Freezable`可以承载数据，而直接使用 `DependencyObject` 不可以？

因为调用链比较长，我只摘取部分较重要的方法剖析

1. 
2. 3
3. 4
4. 5
5. 6
6. 6
7. 7

## 小结

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