## 引言
排序算法是最基础的算法，对于排序算法，除学习算法原理，代码实现之外，更重要的是学习每个算法的特点，知道在什么场景下选择那种算法。

那一定是选择时间复杂度最低的排序算法就是最优的吗？

可以从以下几个方面分析一下。



## 排序算法的执行效率

对于排序算法的执行效率，一般从以下几个方面来分析：
1. 最好时间复杂度，最坏时间复杂度，平均时间复杂度。
   
    在分析排序算法的时间复杂度时，我们要分别给出最好，最坏，平均情况下的时间复杂度，以及这些不同的复杂度对应的待排序数据的特点。对于排序算法，原始数据的**序度（接近有序的程度）**，对排序的执行时间有很大影响（尤其极端情况）。
    
2. 时间复杂度的系数，常数和低阶。
   
   时间复杂度反映的是算法的执行时间随数据规模n的增长趋势，再用大O表示法表示复杂度的时候，通常会省略掉系数，常数和低阶。但是当数据规模很小的时候，系数，常数和低阶的占比很大，也需要考虑。
   
3. 比较次数或交换（或移动）次数。
    
   常用的排序算法，如冒泡排序、插入排序、选择排序、快速排序和归并排序等，是基于比较的排序算法，这类排序算法的执行过程设计两个操作：比较元素大小和交换（或移动）元素位置。而这两个操作的耗时是不同的，比较元素大小的耗时要少于交换（或移动）元素位置。所以，在对排序算法的执行效率进行精细化分析时，要把比较次数和交换（或移动）次数区分开来统计。
   
## 排序算法的内存消耗

算法的内存消耗可以通过空间复杂度来衡量，排序算法也不例外。除空间复杂度分析之外，根据排序算法是否需要额外的非常量级的数据存储空间，可以分为 **原地排序算法（在原数据存储空间上完成排序操作）** 和 **非原地排序算法（需要额外的非常量级的数据存储空间才能完成排序）**。

特别注意的是，原地排序并不与 $O(1)$ 空间复杂度划等号。

一个排序算法是原地排序算法，可能它的空间复杂度并不是 $O(1)$ ，但是，一个排序算法的空间复杂度是 $O(1)$ ，那么它肯定是原地排序算法。

## 排序算法的稳定性

对于大部分算法，只分析执行效率和内存消耗就足够了，不过，**排序算法还有一个特有的分析维度：稳定性，根据稳定性，可以把排序算法分为稳定排序算法和不稳定排序算法。**

如果带排序的数据中存在值相等的元素，经过稳定排序算法排序之后，相等元素之间原有的先后顺序不变。经过不稳定排序算法排序之后，相等元素之间原有的先后顺序可能会被改变。 

例如，有这样一组数据：2、5、9、3、8、5，按照从小到大的的排序之后就变成了2、3、5、5、8、9。

其中数据中有两个5，那么当经过某种排序算法排序之后，两个5的前后顺序无变化，则该排序算法为稳定排序算法，反之，两个5的前后顺序发生变化，则为不稳定排序算法。

那么就产生了疑问，两个5不是一样的吗？

实际上，为了简化对算法的讲解，我们一般是用整数或字符串这些基本数据类型的数据做算法对象演示，但是在真正开发过程中，要排序的对象往往是复杂的数据类型“对象”，按照“对象”的某个属性（称为算法的Key值）进行排序。因此，尽管两个对象的Key值相同，但他们并不是相同的对象。

例如：现在要对电商系统中的“订单”排序，订单有两个属性，“下单时间”和“订单金额”，如果有10万条数据，我们按照金额从小到大排序，对于金额相同的订单，则按照下单时间从早到晚排序。在怎么做？

最先想到的处理方法：首先按照金额对订单进行排序，然后遍历排序之后的订单，对于每个金额相同的小区间在按照下单时间排序，这种排序思路理解起来很直接，符合常规思维，但是实现起来很繁琐。

再来看看借助稳定排序算法的处理思路。我们先按照下单时间给订单排序，注意是按照下单时间而不是金额。在排序完成之后，在利用稳定排序算法，按照订单金额重新排序。在两遍排序后，就达到了预期要求，但是可能理解需要仔细琢磨。

稳定排序算法可以保持金额相同的两个对象，在排序之后的前后顺序不变，在第一次排序之后，所有的订单按照下单时间从早到晚排序，在第二次排序中，我们用稳定排序算法按照金额排序，相同金额的订单原有的先后顺序不变，仍然保持按照下单时间从早到晚排序，如下图：


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

可以看出第一次按下单时间排序后，金额为23元的三个订单ID按顺序分别是3、1、6，经过第二次排序之后他们的订单ID按顺序依旧是3、1、6。

> 参考资料
> 
> [1] 数据结构与算法之美 / 王争 著. --北京：人民邮电出版社，2021.6

数据结构与算法 --- 如何分析排序算法

## 引言

上文[数据结构与算法 --- 递归（一）](https://niuery.com/post/51) 讲述了什么是递归算法，如何编写递归算法及如何写好递归算法，本文着重讲述一下如何避免递归过深导致的堆栈溢出问题。




## 探究产生堆栈溢出的原因

函数调用采用**函数调用栈**来保存当前“快照”（局部变量，返回地址等）。函数调用栈是内存中开辟的一块存储空间，它被组织成“栈”这种数据结构，数据先进后出。

递归的过程包含大量的函数调用，如果递归求解的数据规模很大，函数调用层次很深，那么函数调用栈中的数据（栈帧）会越来越多，而函数调用栈空间一般不大，堆栈空间不足以存储所有的调用信息，从而导致堆栈溢出。

以计算阶乘举例，代码如下：

```csharp
public int Factorial(uint n)
{
    if (n <= 1) return 1;

    return n * Factorial(n - 1);
}
```
当 `Factorial(n)` 执行到 `Factorial(n - 1)` 是，编译器将局部变量，`n` 和 `Factorial(n - 1)` 的返回地址封装为一个栈帧，保存在函数调用栈内，然后再跳转到 `Factorial(n - 1)` 函数体内。

在 `Factorial(n - 1)` 执行完成之后，返回结果（假设是 `result` ），编译器就从函数调用栈中取出之前保存的栈帧（局部变量 `n` 和`Factorial(n - 1)` 的返回地址）。通过返回地址，编译器就知道之前执行到了哪条语句（即 `return n * Factorial(n - 1)` 这条语句），就可以接着从这条语句继续往下执行：将栈帧中保存的 `n` 的值，与 `Factorial(n - 1)` 的结果（即 `result` ）相乘后将结果返回。

那如果不在函数调用栈中存储局部变量，返回地址等信息，是否可行呢？

答案肯定是不行。

- 若不存储返回地址，那么 `Factorial(n - 1)` 执行完之后，编译器就不知道该从哪里继续执行。
- 若不存储局部变量，那么 `Factorial(n - 1)` 执行完之后，编译器即使知道该从哪里执行，但不知道 `n` 的值，也就无法计算 `n * Factorial(n - 1)` 并返回了。 

## 讨论尾递归避免堆栈溢出

什么是尾递归？

**尾递归是指一个递归函数的最后一个操作是递归调用自身，并且该调用的返回值直接返回给函数的调用者，而不进行任何其他的计算或处理。这种形式的递归称为尾递归**。

在尾递归中，递归调用是函数的最后一步操作，因此不需要再次回到递归调用之前的位置来执行其他操作。这意味着尾递归可以被优化为循环，从而避免了递归调用带来的栈空间开销和性能问题。

例如将上述阶乘代码转化为尾递归代码如下：

```csharp
public int Factorial(uint n, int res)
{
    if (n <= 1) return res;
    return Factorial(n - 1, (int)(n * res));
}
```


从理论上来说，尾递归是又可能解决堆栈溢出的问题的。

上文说到，函数调用栈中保存局部变量和返回地址，而对于尾递归代码，递归代码出现在最后一行中，返回之后不需要继续往下执行，因此，返回地址可以不用保存；而局部变量 `n` 也被移动到新的函数 `Factorial(n - 1, n * res)` 中，也不需要保存到栈中。所以对于尾递归代码，不需要想栈里压入数据，也就不存在堆栈溢出的问题。

但是在实际开发过程中，尾递归其实并没有太大作用，不能期望它来规避递归导致的堆栈溢出问题，主要表现在：

- 并不是所有编程语言都支持尾递归优化
- 并不是所有的递归都可以改成尾递归
- 能改成尾递归的代码也就都可以改成迭代方式
- 尾递归代码的可读性差

> 参考资料
> 
> [1] 数据结构与算法之美 / 王争 著. --北京：人民邮电出版社，2021.6

数据结构与算法 --- 递归（二）

## 什么是递归？
**递归（Recursion)** 是一种解决问题的方法，它将问题分解为更小的子问题，并逐层解决这些子问题。递归算法的核心思想是：**一个函数可以直接或间接地调用自身**。通过这种自我调用，我们可以用简洁的代码来解决复杂问题。



##  满足递归的条件
一般来说，满足下面三个条件就可以使用递归：
- 待求解问题的解可以分解为多个子问题的答案。子问题就是数据规模更小的问题。
- 待求解问题与分解之后的问题，只有数据规模不同，求解思路完全相同。
- 存在递归终止的条件。递归问题必须得有终止条件，否则将会无限循环。


## 如何编写递归代码

编写递归代码的关键是将符合递归条件的问题公式化，将问题变成递推公式，寻找终止条件，然后根据公式“翻译”为代码。

例如[斐波那契数列](https://zh.wikipedia.org/wiki/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97)的问题：数列的前两项为1，从第三项开始，每一项都等于前两项之和，那么求解斐波那契数列的第$n$项则有：
- $n$为正整数 $n$∈N 
- 当$n=1$或$n=2$，值为1
- 当$n>2$时，则$f(n)=f(n-1)+f(n-2)$

则有

$$
 f(x) =
\begin{cases}
1 & 0< x\leq 2 \\
f(x-1)+f(x-2) & x>2
\end{cases}\qquad x∈N
$$

然后将上述公式“翻译”为代码，如下所示：


```csharp
public int Fibonaci(uint n)
{
    if (n > 0 && n <= 2) return 1;

    return Fibonaci(n - 1) + Fibonaci(n - 2);
}
```

所以，编写递归代码的关键就是找到将大问题分解为小问题的规律，并且基于此写出递推公式，然后找出终止条件，最后将公式"翻译"成代码。

## 递归的堆栈溢出问题

在函数调用会使用栈来保存临时变量，每调用一个新的函数，都会将临时变量封装为栈帧，压入内存栈，等函数执行完成后，再将栈帧出栈，所以，如果递归求解的数据规模很大，调用层次很深，一直往函数栈里添加数据，就会塞满函数栈，导致堆栈溢出。

如何避免出现堆栈溢出呢？**可以通过在代码中限制递归调用的最大深度**。

假设限制递归深度为1000，则修改后代码：

```csharp
static int depth = 0;

public static int Fibonaci(uint n)
{
    depth++;

    if (depth > 1000) throw new Exception("超出递归范围！");

    if (n > 0 && n <= 2) return 1;

    return Fibonaci(n - 1) + Fibonaci(n - 2);
}
```
## 递归的重复计算问题

除堆栈溢出问题外，编写递归还会出现重复计算的问题，例如上述斐波那契数列的递归，在执行时就有重复计算的问题。

例如，当计算 `Fibonaci(5)` 的时候，需要计算 `Fibonaci(4)` 和 `Fibonaci(3)`，而计算 `Fibonaci(4)` 又需要计算 `Fibonaci(3)` 和 `Fibonaci(2)`，以此类推。因此，`Fibonaci(3)` 这个值就被计算了两次，`Fibonaci(2)` 这个值就被计算了三次。

为了避免重复，可以使用字典将计算过的值存储下来，当递归调用到已经计算过的值时，直接从字典中取值并返回，这样就省掉了重复计算。

将上文中的代码再进行优化：

```csharp
static int depth = 0;

static Dictionary<uint, int> ValuePairs = new Dictionary<uint, int>();

public static int Fibonaci(uint n)
{
    depth++;

    if (depth > 1000) throw new Exception("超出递归范围！");

    if (n > 0 && n <= 2) return 1;

    if (ValuePairs.ContainsKey(n))
    {
        return ValuePairs[n];
    }

    var res = Fibonaci(n - 1) + Fibonaci(n - 2);

    ValuePairs.Add(n, res);

    return res;
}
```

## 将递归代码改写为非递归代码

使用递归编程有利有弊，递归编程的好处是使用递归编写的代码的表达能力强，写起来简洁，而递归编程的劣势是空间复杂度高，且存在堆栈溢出和重复计算的问题，因此，在实际开发过程中，可以根据实际情况来决定是是否使用递归实现，例如可以将上述的斐波那契数列的代码改为非递归代码，如下所示：

```csharp
public static int Fibonaci(uint n)
{

    if (n > 0 && n <= 2) return 1;

    int prev = 1;

    int prev_prev = 1;

    int result = 0;
    
    for (int i = 2; i < n; i++)
    {
        result = prev + prev_prev;

        prev_prev = prev;

        prev = result;
    }

    return result;
}

```

所有递归算法都可以改写为迭代循环的非递归写法吗？

是，理论上所有递归算法都可以改写为迭代循环的非递归写法。这是因为递归算法本质上是一个函数在自己内部不断调用自己，而迭代循环可以通过变量的更新来达到相同的效果。

具体来说，可以通过使用一个栈或队列等数据结构来模拟递归函数的调用过程。每当递归函数需要调用自身时，将当前的参数值和程序计数器等信息保存到栈或队列中，然后继续执行下一个语句。当递归函数返回时，从栈或队列中弹出保存的信息，恢复之前的状态，并继续执行之前被中断的语句。

虽然理论上可以将所有递归算法改写为迭代循环的非递归写法，但实际上有些算法可能更适合使用递归实现，而另一些算法则更适合使用迭代循环实现。例如，递归算法通常在树形结构的遍历和图形搜索等算法中使用，而迭代循环则更适合处理数值计算等需要大量循环迭代的算法。


## 总结 

递归式一种高效，简洁的编码模式，只要满足递归的3个条件，就可以使用递归算法去实现。不过，递归代码比较难写，难理解。编写递归代码的关键是不要试图去模拟计算机递归调用的过程，正确的编写方式是写出递推公式，找出终止条件，然后"翻译"为代码。

递归也有它自己的弊端，比如堆栈溢出，重复计算，函数调用耗时多和空间复杂度高，所以在编写递归算法代码时，要避免出现这些问题。


> 参考资料
> 
> [1] 数据结构与算法之美 / 王争 著. --北京：人民邮电出版社，2021.6

数据结构与算法 --- 递归（一）

## 引言
现在模拟一个异步方法抛出了异常：

```csharp
public static async Task ThrowAfter(int ms, string message)
{
    await Task.Delay(ms);
    throw new Exception(message);
}
```

思考一下， `DontHandle()` 方法是否能够捕获到异常？

```csharp
public static void DontHandle()
{
    try
    {
        ThrowAfter(1000, "first");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }

}

```


答案是：不会捕获到异常！

因为 `DontHandle()` 方法在 `ThrowAfter()` 方法抛出异常之前，就已经执行完毕。


## 异步方法的异常处理

那么上述代码怎么才能捕获到异常呢？

若想要捕获异常则必须通过 `await` 关键字等待 `ThrowAfter()` 方法执行完成。

将上文中的代码段进行修改：

```csharp
public static async void HandleoOnError()
{
    try
    {
        await ThrowAfter(1000, "first");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
```
结果就会输出：

```csharp
first
```

## 多个异步方法的异常处理

如果调用两个异步方法，每个都会抛出异常，该如何处理呢？

我们可以这样写：

```csharp
public static async void StartTwoTasks()
{
    try
    {
        await ThrowAfter(1000, "first");
        await ThrowAfter(1000, "second");
        Console.WriteLine("StartTwoTasks is Complate");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
```
思考一下输出是什么？

答案是：

```csharp
first
```
并没有预想中的两个异常都捕获打印出来，也没有看到“StartTwoTasks is Complate”这句话打印出来。因为使用 `await` 关键字之后，两次调用 `ThrowAfter()` 方法就变成了同步执行，捕获到第一次的异常之后直接进入到 `catch` 代码段，不再执行后续代码。

可以尝试解决这个问题，使用 `Task.WhenAll()` 方法，该方法不管任务是否抛出异常，都会等到两个任务完成。如下代码：

```csharp
public static async void StartTwoTasksParallel()
{
    try
    {
        Task t1 = ThrowAfter(1000, "first");
        Console.WriteLine("t1 is Complate");
        Task t2 = ThrowAfter(1000, "second");
        Console.WriteLine("t2 is Complate");
        await Task.WhenAll(t2, t1);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
```

输出：

```csharp
t1 is Complate
t2 is Complate
second
```

从输出可以看出来，使用 `WhenAll()` 方法，两个任务都是执行完成的，但是，捕获异常只能捕获 `WhenAll()`方法参数中，排在最前面的，且第一个抛出异常的任务的消息，

上述方式有缺陷，只能抛出一个异常的任务的消息，可以将上面的方式再进化一下，如下代码：

```csharp
public static async void StartTwoTasksParallelEx()
{
    Task t1 = null;
    Task t2 = null;
    try
    {
        t1 = ThrowAfter(1000, "first");
        t2 = ThrowAfter(1000, "second");
        await Task.WhenAll(t2, t1);

    }
    catch (Exception ex)
    {
        if (t1.IsFaulted)
        {
            Console.WriteLine(t1.Exception.InnerException.Message);
        }

        if (t2.IsFaulted)
        {
            Console.WriteLine(t2.Exception.InnerException.Message);
        }
    }
}
```
输出：

```csharp
first
second
```


在 `try/catch` 代码块外声明任务变量t1、t2，使他们可以在 `try/catch` 块内访问，在这里，使用了`IsFaulted` 属性，检查任务的状态，若`IsFaulted` 属性为 `true` ，则表示该任务出现异常，就可以使用 `Task.Exception.InnerException` 访问异常本身。

## 使用AggregateException信息

除了上述方式外，还有一种更好的获取所有任务的异常信息的方式，`Task.WhenAll()` 方法返回的结果其实也是一个 `Task` 对象，而 `Task` 有一个 `Exception` 属性，它的类型是 `AggregateException`，是 `Exception`的一个派生类，`AggregateException` 类有一个 `InnerExceptions` 属性（异常集合，包含 `Task.WhenAll()` 方法列表中所有异常任务的异常信息）。

有了这个属性则可以轻松遍历所有异常。如下代码：

```csharp
public static async void StartTwoTasksParallelEx2()
{
    Task t3 = null;
    try
    {
        Task t1 = ThrowAfter(1000, "first");
        Task t2 = ThrowAfter(1000, "second");
        await (t3 = Task.WhenAll(t2, t1));

    }
    catch (Exception ex)
    {
        foreach (var item in t3.Exception.InnerExceptions)
        {
            Console.WriteLine("InnerException:" + item.Message);
        }
    }
}
```

输出：
```csharp
InnerException:second
InnerException:first
```

## 总结

除了前面提到的异步方法异常处理的基本知识点，以下是一些进阶的异常处理技巧：

- 在异步方法中，如果需要将异常传递给调用方，请不要直接抛出异常。相反，应该使用 throw 关键字将异常包装在一个 `Task` 或 `ValueTask` 对象中，并将其返回给调用方。这可以避免在异步操作中丢失异常信息。

- 如果需要在异步方法中处理多个异常，可以使用 `catch` 块来捕获不同类型的异常，并根据需要执行不同的处理操作。还可以使用 `finally` 块来执行清理操作，例如释放资源或恢复状态。

- 如果需要在异步方法中执行一些异步操作，并且这些操作都必须成功才能继续执行下一步操作，那么可以使用 `Task.WhenAll` 方法来等待所有异步操作完成。如果任何一个异步操作失败，`WhenAll` 方法将返回一个 `AggregateException` 对象，其中包含所有失败的异常。

- 如果需要在异步方法中执行多个异步操作，并且这些操作中的任何一个失败都将导致整个操作失败，那么可以使用 `Task.WhenAny` 方法来等待第一个异步操作完成。如果第一个操作失败，`WhenAny` 方法将返回一个 `AggregateException` 对象，其中包含第一个失败的异常。

- 如果需要在异步方法中进行错误处理并且希望能够获取更多有关异常的信息，可以使用 `ExceptionDispatchInfo` 类。这个类可以捕获异常并将其存储在一个对象中，然后在需要时重新抛出异常。这可以帮助在异步操作中保留异常信息，并将其传递给调用方。

总之，在异步方法中处理异常时，需要注意一些细节和技巧，例如正确处理异常、捕获多个异常、等待多个异步操作、以及使用 `ExceptionDispatchInfo` 类来捕获异常。掌握这些处理技巧可以帮助编写更可靠、更健壮的异步代码。

并发编程 --- 异步方法的异常处理

## 引言
在实际开发场景中，当ViewModel内的一个属性是一个 `ObservableCollection<T>` 或者是一个多层级 `class` 的时候，有可能有的需求需要 `ObservableCollection<T>`内的元素的子属性或多层级 `class` 的子属性，甚至子属性的子属性，变化，需要通知到ViewModel，该怎么做呢？



例如我有一个设置功能模块，十几个模型，一两百个属性参数，模型之间是2~3层的嵌套关系，最后得到一个大模型表示Model，我想要在子属性的值变化的是通知到ViewModel，记录日志或其他操作。


现有的MVVM框架，例如 `MVVMLight` ，`Prism` ， 我好像都没有找到这样的功能，如果有更好的方案或实现，烦请告之。

现在手动实现一个这样的辅助类。接下来看一下实现过程：

### INotifyHolder接口
 
先定义 `INotifyHolder` 接口，用于通知 `HolderViewModel` ，有属性变化了。

```csharp
namespace MvvmNoticeHolderLib
{
    public interface INotifyHolder
    {
        void AfterPropertyChangedNotified(object sender, string info);
    }
}
```
### NoticeFlagAttribute特性
定义 `NoticeFlagAttribute` 特性，用于标记哪些属性是需要在变化时通知到 `HolderViewModel` 的。
```csharp
namespace MvvmNoticeHolderLib
{

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
    public class NoticeFlagAttribute : Attribute
    {
        public string Name { get; set; } = string.Empty;
        
        public Type Type { get; set; }

        public NoticeFlagAttribute(string names, Type type)
        {
            Name = names;
            Type = type;
        }
    }
}
```
###  NotifyHolder的Binding管理器

```csharp
namespace MvvmNoticeHolderLib
{
    public class NotifyHolderBindingManager
    {
        private static T BindSlaveProperty<T>(T source, object root)
        {
            try
            {
                if (source != null)
                {
                    var type = source.GetType();

                    var properties = type.GetProperties();

                    var NoticeFlags = type.GetCustomAttributes<NoticeFlagAttribute>();

                    if (NoticeFlags != null && NoticeFlags.Count() > 0)
                    {
                        foreach (var noticeFlag in NoticeFlags)
                        {
                            PropertyInfo info = properties.SingleOrDefault(x => x.Name == noticeFlag.Name);

                            if (info != null)
                            {
                                BindProperty(source, root, info);
                            }
                        }
                    }
                }
                return source;
            }
            catch (Exception ex)
            {
                return source;
            }
        }

        public static T BindSelfProperty<T>(T root)
        {
            try
            {
                if (root != null)
                {
                    var type = root.GetType();

                    var properties = type.GetProperties();

                    var NoticeFlags = type.GetCustomAttributes<NoticeFlagAttribute>();

                    if (NoticeFlags != null && NoticeFlags.Count() > 0)
                    {
                        foreach (var noticeFlag in NoticeFlags)
                        {
                            PropertyInfo info = properties.SingleOrDefault(x => x.Name == noticeFlag.Name);

                            if (info != null)
                            {
                                BindSlaveProperty(root, root);

                                var tmp = info.GetValue(root);

                                if (root is INotifyPropertyChanged notify)
                                {
                                    notify.PropertyChanged += (sender, e) =>
                                    {
                                        if (NoticeFlags.Any(t => t.Name == e.PropertyName))
                                        {
                                            var senderType = sender.GetType();
                                            PropertyInfo senderProperty = senderType.GetProperty(e.PropertyName);
                                            BindProperty(sender, sender, senderProperty);
                                        }
                                    };
                                }
                            }
                        }
                    }
                }
                return root;
            }
            catch (Exception)
            {
                return root;
            }
        }

        private static void BindProperty<T>(T source, object root, PropertyInfo info)
        {
            if (info.PropertyType.IsGenericType && info.PropertyType.GetGenericTypeDefinition() == typeof(ObservableCollection<>))
            {
                var tmp = info.GetValue(source);

                if (tmp != null && tmp is INotifyCollectionChanged notifyCollectionChanged)
                {
                    notifyCollectionChanged.CollectionChanged += (sender, e) =>
                    {
                        if (e.NewItems != null && e.NewItems.Count > 0)
                        {
                            BindSlaveProperty(e.NewItems[0], root);

                            if (e.NewItems[0] != null && e.NewItems[0] is INotifyPropertyChanged notify)
                            {
                                if (root is INotifyHolder notifyHolder)
                                {
                                    notify.PropertyChanged += (s, e) =>
                                    {
                                        notifyHolder.AfterPropertyChangedNotified(s, info.Name + "." + e.PropertyName + "发生了变化");
                                    };
                                }
                            }
                        }
                    };

                    var arr = (IEnumerable<object>)tmp;
                    foreach (var item in arr)
                    {
                        if (item is INotifyPropertyChanged notify && root is INotifyHolder notifyHolder)
                        {
                            BindSlaveProperty(item, root);
                            notify.PropertyChanged += (sender, e) =>
                            {
                                notifyHolder.AfterPropertyChangedNotified(sender, info.Name + "." + e.PropertyName + "发生了变化");
                            };
                        }
                    }
                }
            }
            else if (info.PropertyType.GetInterfaces().Contains(typeof(INotifyPropertyChanged)))
            {
                var tmp = info.GetValue(source);
                if (tmp != null && tmp is INotifyPropertyChanged notify)
                {
                    BindSlaveProperty(tmp, root);
                    if (root is INotifyHolder notifyHolder)
                    {
                        notify.PropertyChanged += (sender, e) =>
                        {
                            notifyHolder.AfterPropertyChangedNotified(sender, info.Name + "." + e.PropertyName + "发生了变化");
                        };
                    }
                }
            }
        }
    }
}

```
 
这个类就是实现这个功能的核心，其主要原理是，通过 `NoticeFlagAttribute` 特性，获取你要绑定的属性，然后  监控你要绑定的属性的 `INotifyPropertyChanged` 的`PropertyChanged` 事件或者是 `INotifyCollectionChanged` 的 `CollectionChanged`事件，最后通知到 `HolderViewModel` 中，若子属性有多层级关系，可以多层级中每个层级使用 `NoticeFlagAttribute` 特性，标记你想要监控的属性，然后Binding管理器通过递归方式依次绑定好，就实现了多层级的监控通知到 `HolderViewModel` 中。

我已将Demo发布到github，Readme.md中有使用说明。
 
>github仓库地址
>
>https://github.com/PeterPandefu/MvvmNoticeHolder