## 引言

今天看书看到了这样一个问题：

**假设有10个接口访问的日志，每个日志的大小为300M，每个文件里的日志都是按照时间戳从小到大排序的。现在我们希望将这10个较小的日志文件，合并为一个大文件，合并之后的文件依旧按照时间戳从小到大排序，如果处理上述任务的机器只有1G内存，那么该如何将这10个日志文件合并？**




一般来说，如果机器内存足够大，可以直接将所有数据全部加载到内存，然后整合到一个集合后进行排序后输出一个大文件。但并不建议这样操作，这样无节制的使用内存，可能会导致性能下降甚至程序崩溃。


## 思路

那我们如何在有限条件下处理这样的有序多文件合并为有序大文件呢？先想想C#是如何读取大文件的？

C#处理大文件的方法是使用流（Stream）而不是一次性将整个文件加载到内存中。


```csharp
int bufferSize = 1024 * 1024; // 使用1MB的缓冲区

byte[] buffer = new byte[bufferSize];

try
{
    using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
    {
        int bytesRead;

        while ((bytesRead = fileStream.Read(buffer, 0, bufferSize)) > 0)
        {
            // do something... 
        }

    }
}
catch
{

}
```

那我们要多个有序文件合并成一个文件，就反过来，我们从每个文件中取出最小的数据，然后分多路依次合并到目标文件中。这其实就是**归并排序中的 `Merge()`函数的处理思路**。想仔细了解可以看一下[数据结构与算法 --- 排序算法（二）](https://niuery.com/post/56)

## 实现
可以将文件看作数组，那问题就变成了多个有序数组合并为一个有序数组。

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

用C#代码实现如下：

```csharp
public static void Main()
{
    //这里暂时只使用3组数据
    int[][] sortedArrays = new int[][]
    {
        new int[] { 1, 4, 7, 10, 13 },
        new int[] { 2, 5, 8, 11, 14 },
        new int[] { 3, 6, 9, 12, 15 },

    };

    int[] mergedArray = MergeSortedArrays(sortedArrays);
    Console.WriteLine("合并后的有序数组：");
    foreach (int num in mergedArray)
    {
        Console.Write(num + " ");
    }
}

private static int[] MergeSortedArrays(int[][] arrays)
{
    int totalLength = 0;
    foreach (int[] arr in arrays)
    {
        totalLength += arr.Length;
    }

    int[] mergedArray = new int[totalLength];
    int[] currentIndex = new int[arrays.Length];

    for (int i = 0; i < totalLength; i++)
    {
        int minIndex = -1;
        int minValue = int.MaxValue;

        // 在所有数组中选择最小值
        for (int j = 0; j < arrays.Length; j++)
        {
            if (currentIndex[j] < arrays[j].Length && arrays[j][currentIndex[j]] < minValue)
            {
                minValue = arrays[j][currentIndex[j]];
                minIndex = j;
            }
        }

        // 将最小值放入合并后的数组
        mergedArray[i] = minValue;
        currentIndex[minIndex]++;
    }

    return mergedArray;
}

```
在上面的示例代码中，我们模拟创建了3个有序数组（`sortedArrays`），然后调用 `MergeSortedArrays` 方法来将这些有序数组合并为一个有序数组。在 `MergeSortedArrays` 方法中，我们使用了一个辅助数组 `currentIndex` 来记录每个有序数组当前的索引位置。然后，我们依次从所有数组中选择最小值，将其放入合并后的数组中，并更新对应数组的索引。重复这个过程直到合并后的数组填满，即得到了合并后的有序数组。

上述代码执行结果：

```csharp
合并后的有序数组：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
```

那么如果换成日志文件，为了解决内存条件限制，则可以为每个小文件及最终的排序文件，都前置一个内存缓存（数组），在读取数据时，一次性读取一批数据到内存（如同文章开头的示例），同理，写入数据时，先写数据到内存，等内存满了之后，在一次性地将内存中的数据写入到最终的排序文件中。

至于为什么要等到内存满了才写入，是因为磁盘的读写速度远慢于内存的读写速度，等到内存满了在写入，能够充分利用内存，节省执行时间，提高效率，但是还是需要注意尺度，避免程序直接崩溃

编码技巧 --- 内存有限下合并大文件

## 引言
上一篇[数据结构与算法 --- 排序算法（二）](https://niuery.com/post/56)中，介绍了分治算法思想及借助分治算法思想实现的归并排序。

本篇来讲解一下快速排序，它也是借助分治算法思想实现，但其处理思路与归并排序完全不一样。



## 快速排序

来看一下快速排序的算法原理：

### 算法图解

如果要排序数组中 $p$ 到 $r$ 的数据，那么，我们选择 $p$ 到r之间的任意一个数据作为 $pivot$（分区点），然后遍历从 $p$ 到 $r$ 的数据，将小于 $pivot$ 的放到左边，将大于或等于 $pivot$ 的放右边，将 $pivot$ 放中间，经过这一步骤处理之后，从 $p$ 到 $r$ 的数据就被分成了3部分。

假设 $pivot$ 现在的位置下标是 $q$，那么从 $p$ 到 $q-1$ 的数据都小于 $pivot$ ，中间是 $pivot$ ，从$q+1$ 到 $r$ 都是大于 $pivot$，如下图：


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

根据分治的处理思想，分区完成之后，开始递归下标从 $p$ 到 $q-1$ 的数据和下标$q+1$ 到 $r$ 的数据，知道待排序区间的大小缩小为1，就说明数据都有序了。

如果使用递推公式将上面的过程表示出来，递推公式：

$$
quick\_sort(p,r)=partition(p,r)+quick\_sort(p,q-1)+quick\_sort(q+1,r) \qquad  终止条件：p \ge r
$$

其中 `partition()` 分区函数要做的就是随机选择一个元素作为 $pivot$（一般选择$p$ 到$r$区间中的最后一个元素），然后基于 $pivot$ 对区间 `Arr[p,r]` 进行分区，分区函数返回分区之后的 $piovt$ 的下标。

使用C#代码实现快速排序：

```csharp
class QuickSort
{
    public static void Sort(int[] arr)
    {
        if (arr == null || arr.Length == 0)
            return;

        QuickSortRecursive(arr, 0, arr.Length - 1);
    }

    private static void QuickSortRecursive(int[] arr, int left, int right)
    {
        if (left >= right)
            return;

        int pivotIndex = Partition(arr, left, right);
        QuickSortRecursive(arr, left, pivotIndex - 1);
        QuickSortRecursive(arr, pivotIndex + 1, right);
    }

    private static int Partition(int[] arr, int left, int right)
    {
        //这里可以选择不同的策略，比如随机数选取或选择中间值
        int pivotIndex = ChoosePivot(left, right);
        int pivotValue = arr[pivotIndex];
        Swap(arr, pivotIndex, right);

        int currentIndex = left;
        for (int i = left; i < right; i++)
        {
            if (arr[i] < pivotValue)
            {
                Swap(arr, i, currentIndex);
                currentIndex++;
            }
        }

        Swap(arr, currentIndex, right);
        return currentIndex;
    }

    private static int ChoosePivot(int left, int right)
    {
        //这里选择使用中间值
        return (left + right) / 2; 
    }

    private static void Swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
```

### 算法分析

**内存消耗**：

如果不考虑空间消耗的话，那么 `partition()` 分区函数实现非常简单，直接申请两个临时数组 X 和 Y，遍历目标区间 `Arr[p,r]` ，小于 $pivot$ 的直接复制到X，大于 $pivot$ 的直接复制到Y，最后按顺序将X，$pivot$，Y依次复制到目标区间 `Arr[p,r]`。

但是，如果这样实现的话， `partition()` 执行的过程中将消耗很多额外内存空间，快速排序也就不是原地排序算法了，如果希望快速排序是原地排序算法，该怎么做呢？

这就需要之前文章中提到的**通过交换来避免搬移**， 具体实现类似选择排序，通过游标 $i$ 把`Arr[p,r-1]` 分成两个部分，`Arr[p,i-1]` 的元素都小于 $pivot$ (也就是`Arr[r]`)，暂且称之为“已处理区间”，对应的，`Arr[i,r-1]` 是“未处理区间”。每次从未处理区间 `Arr[i,r-1]` 中取出一个元素`Arr[j]` 与 $pivot$ 对比，如果小于 $pivot$ ，则将其插入到已处理区间的尾部，也就是下标为 $i$ 的位置。具体图解可以参考[数据结构与算法 --- 排序算法（一）](https://niuery.com/post/54)中的选择排序算法图解。

**稳定性**：

理解完了快速排序是原地排序算法，那么分析一下该排序算法是否稳定排序？

其实也很简单，排序算法涉及到了分区，分区的操作实现又是按照选择排序原理实现，选择排序本身就是不稳定排序算法，所以快速排序也是不稳定排序。（）


**时间复杂度**：

1. 最好情况时间复杂度：$O(nlogn)$

   在最好的情况下，快速排序的时间复杂度为 $O(n log n)$。这种情况发生在每次划分时，待排序数组恰好被平均地分成两个大小相近的子数组。此时，快速排序的递归树的深度较小，每一层的时间复杂度为 $O(n)$，总的时间复杂度为 $O(n log n)$。

2. 最坏情况时间复杂度：$O(n^2)$
   
   在最坏的情况下，快速排序的时间复杂度为 $O(n^2)$。这种情况发生在每次划分时，待排序数组中的元素都被划分到了同一侧，导致一侧的子数组非常大，另一侧为空。这样就会导致快速排序的递归树非常不平衡，每一层的时间复杂度为 $O(n)$，而递归的层数为n，因此总的时间复杂度为 $O(n^2)$。

3. 平均情况时间复杂度：$O(n log n)$
   
   在平均情况下，快速排序的时间复杂度为 $O(n log n)$。快速排序采用分治策略，在平均情况下，待排序数组会被平均地划分成两个大小相近的子数组，这样递归树会相对平衡，每一层的时间复杂度为 $O(n log n)$，总的时间复杂度为 $O(n log n)$。

## 总结

需要注意的是，快速排序的性能高度依赖于划分元素的选择。在实际实现中，通常会采取一些优化措施，如三数取中法或随机选取划分元素，以尽量避免最坏情况的发生。总体来说，快速排序在大多数情况下表现良好，因为平均时间复杂度为$O(n log n)$，它是一种快速且高效的排序算法。
 
>参考
>
> [1] 数据结构与算法之美 / 王争 著. --北京：人民邮电出版社，2021.6

数据结构与算法 --- 排序算法（三）

## 引言

随着高性能系统越来越普遍地采用.NET环境，垃圾回收器的决策过程正在变得越来越优雅。

本篇介绍一下垃圾回收的基本运作方式。



## 小对象堆和大对象堆
在托管进程中存在两种内存堆（本机堆和托管堆）。本机内存堆(`Native Heap`)是由 `VirtualAlloc` 这个 `Windows API` 分配的，是由操作系统和CLR使用的，用于非托管代码所需的内存，比如 `Windows API` 、操作系统数据结构、很多CLR数据等。

CLR在托管堆(`Managed Heap`)上为所有.NET托管对象分配内存，也被成为GC堆，因为其中的对象均要受到垃圾回收机制的控制。

托管堆又分为两种一**小对象堆**和**大对象堆**（`LOH`),两者各自拥有自己的内存段(`Segment`)。每个内存段的大小视配置和硬件环境而定，对于大型程序可以是几百MB或更大。

小对象堆和 `LOH` 都可拥有多个内存段。小对象堆的内存段进一步划分为3代，分别是0、1、2代。第0代和第1代总是位于同一个内存段中，而第2代可能跨越多个内存段，`LOH` 也可以跨越多个内存段。包含第0代和第1代堆的内存段被称为暂时段(`Ephemeral Segment`)。

一开始内存堆就如下所示，两个内存段分别被标为 A 和 B，内存地址从左到右由小变大。小对象堆由 A 段内存构成，`LOH` 拥有 B 段内存。第 2 代和第 1 代堆只占有开头的一点内存，因为它们还都是空的。


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

### 小对象堆中分配内存的对象的生存期
如果对象小于 85 000 字节，CLR 都会把它分配在小对象堆中的第 0 代，通常紧挨着当前已用内存空间往后分配。因
此，正如本章开头所示，.NET 的内存分配过程非常迅速。如果快速分配失败，对象就可能会被放入第 0 代内存堆中的任意地方，只要能容纳得下就行。

如果没有合适的空闲空间，那么分配器就会扩大第 0 代内存堆，以便能存入新对象。如果扩大内存堆时超越了内存段的边界，则会触发垃圾回收过程。

对象总是诞生于第 0 代内存堆。只要对象保持存活，每当发生垃圾回收时，GC 都会把它提升一代。第 0 代和第 1 代内存堆的垃圾回收有时候被称为瞬时回收（`Ephemeral Collection`）。

在发生垃圾回收时，可能会进行碎片整理（`Compaction`），也就是 GC 把对象物理迁移到新的位置中去，以便让内存段中的空闲空间能够连续起来以备使用。如果未发生碎片整理，那就只需要重新调整各块内存的边界即可。在经历了几次未做碎片整理的垃圾回收之后，内存堆的分布可能会如下所示。


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

对象的位置没有移动过，但各代内存堆的边界已经发生了变化。

每一代内存堆都有可能发生碎片整理。因为 GC 必须修正所有对象的引用，使它们指向新的位置，所以碎片整理的开销相对较大，还有可能需要暂停所有托管线程。正因如此，垃圾回收器只在划算（`Productive`）时才会进行碎片整理，判断的依据是一些内部指标。

如果对象到达了第 2 代内存堆，它就会一直留在那里直至终结。这并不意味着第 2 代内存堆只会一直变大。

如果第 2 代内存堆中的对象都终结了，整个内存段也没有存活的对象了，垃圾回收器会把整个内存段交还给操作系统，或者作为其他几代内存堆的附加段。

在进行完全垃圾回收（`Full Garbage Collection`）时，就可能发生这种第 2 代内存堆的回收。

那么“存活”是什么意思呢？如果 GC 能够通过任一已知的 GC 根对象（Root），沿着层层引用访问到某个对象，那它就是存活的。

GC 根对象可以是程序中的静态变量，或者某个线程的堆栈被正在运行的方法占用（用于局部变量），或者是 GC 句柄（比如固定对象的句柄，`Pinned Handle`），或是终结器队列（`Finalizer Queue`）。

请注意，有些对象可能没有受GC 根对象的引用，但如果是位于第 2 代内存堆中，那么第 0 代回收是不会清理这些对象的，必须等到完全垃圾回收才会被清理到。


如果第 0 代堆即将占满一个内存段，而且垃圾回收也无法通过碎片整理获取足够的空闲内存，那么 GC 会分配一个新的内存段。新的内存段会用于容纳第 1 代和第 0 代堆，老的内存段将会变为第 2 代堆。老的第 0 代堆中的所有对象都会被放入新的第 1 代堆中，老的第 1代堆同理将提升为第 2 代堆（提升很方便，不必复制数据）。现在的内存段将如下所示。


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


如果第 2 代堆继续变大，就可能会跨越多个内存段。LOH 堆同样也可能跨越多个内存段。无论存在多少个内存段，第 0 代和第 1 代总是位于同一个段中。以后我们想找出内存堆中有哪些对象存活时，这些知识将会派上用场。

### 大对象堆中分配内存的对象的生存期
LOH 则遵从另一套回收规则。大于 85 000 字节的对象将自动在 LOH 中分配内存，且没有什么“代”的模式。超过这个尺寸的对象通常也就是数组和字符串了。

出于性能考虑，在垃圾回收期间 LOH 不会自动进行碎片整理，但从.NET 4.5.1 开始，必要时你也可以人为发起碎片整理。

与第 2 代内存堆类似，如果 LOH 的内存不再有用了，就可能会被用于其他内存堆。不过我们以后将会看到，理想状态下你根本就不会愿意让 LOH 的内存被回收掉。在 LOH 中，垃圾回收器用一张空闲内存列表来确定对象的存放位置。


:::tip{title="提示"}
如果是在调试器中查看位于 LOH 的对象，你会发现有可能整个 LOH 都小于 85 000 字节，而且可能还有对象的大小是小于已分配值的。这些对象通常都是 CLR 分配出去的，可以不予理睬。
:::

垃圾回收是针对某一代及其以下几代内存堆进行的。如果回收了第 1 代，则也会同时回收第 0 代。

如果回收了第 2 代，则所有内存堆都会回收，包括 LOH。如果发生了第 0 代或第1 代垃圾回收，那么程序在回收期间就会暂停运行。对于第 2 代垃圾回收而言，有部分回收是在后台线程中进行的，这要根据配置参数而定。

## 垃圾回收的四个阶段
垃圾回收包含 4 个阶段。
1. 挂起（Suspension）—— 在垃圾回收发生之前，所有托管线程都被强行中止。
2. 标记（Mark）—— 从 GC 根对象开始，垃圾回收器沿着所有对象引用进行遍历并把所见对象记录下来。
3. 碎片整理（Compact）—— 将对象重新紧挨着存放并更新所有引用，以便减少内存碎片。在小对象堆中，碎片整理会按需进行，无法控制。在 LOH 中，碎片整理不会自动进行，但你可以在必要时通知垃圾回收器来上一次。
4. 恢复（Resume）——托管线程恢复运行。

在标记阶段并不需要遍历内存堆中的所有对象，只要访问那些需要回收的部分即可。

比如第 0 代回收只涉及到第 0 代内存堆中的对象，第 1 代回收将会标记第 0 代和第 1 代内存堆中的对象。

而第 2 代回收和完全回收，则需遍历内存堆中所有存活的对象，这一过程的开销有可能非常大。

这里有个小问题需要注意，高代内存堆中的对象有可能是低代内存堆对象的根对象。这样就会导致垃圾回收器遍历到一部分高代内存堆的对象，但这样的回收开销还是小于高代内存堆的完全垃圾回收。


## 结论

由上述讨论可以形成以下几点重要结论。

第一，垃圾回收过程的耗时几乎完全取决于所涉及“代”内存堆中的对象数量，而不是你分配到的对象数量。这就是说，即使你分配了 1 棵包含 100 万个对象的树，只要在下一次垃圾回收之前把根对象的引用解除掉，这 100 万个对象就不会增加垃圾回收的耗时。

第二，垃圾回收的频率取决于所涉及“代”内存堆中已被占用的内存大小。只要已分配内存超过了某个内部阈值，就会发生该“代”垃圾回收。

这个阈值是持续变化的，GC 会根据进程的执行情况进行调整。如果某“代”回收足够划算（提升了很多对象所处的“代”），那垃圾回收就会发生得频繁一些，反之亦然。

另一个触发垃圾回收的因素是所有可用内存，与你的应用程序无关。如果可用内存少于某个阈值，为了减少整个内存堆的大小，垃圾回收可能会更为频繁地发生。

由上所述，貌似垃圾回收是难以控制的，但事实不是这样。通过控制内存分配模式来控制垃圾回收的统计指标，就是一种最容易实现的优化方法。这需要理解垃圾回收的工作机制、可用的配置参数、你的内存分配率，还需要对对象的生存期有很好的控制能力。


>上述文章引用自
>
>编写高性能的.NET代码/（美）沃森(Ben Watson)著；戴旭译. --北京：人民邮电出版社，2017.8

基础进阶 --- 垃圾回收的基本运作方式

# 引言

内训师是负责组织和实施公司内部培训的专业人士。他们在组织内部开展培训活动，提供必要的知识和技能，以帮助员工在工作中取得成功。



以下是内训师的主要职责和作用：

1. 需求分析：内训师需要与公司管理层和各部门合作，了解培训需求和目标。他们会收集反馈意见、进行员工调研，并分析组织的培训需求，以确定最佳的培训方案。

2. 培训计划设计：基于需求分析的结果，内训师将制定培训计划和时间表。他们会确定培训的目标、内容、培训方法和评估方式，以确保培训活动的有效性和可衡量性。

3. 培训材料开发：内训师会开发或整理培训所需的教材、幻灯片、案例研究等教学资料。他们会确保培训材料的准确性和相关性，并根据目标受众的需求进行定制化设计。

4. 培训交付：内训师是培训活动的主要讲师或导师。他们将根据培训计划，组织并传授培训内容，使用合适的教学方法和工具，以确保员工能够理解和掌握所需的知识和技能。

5. 培训评估：内训师会进行培训效果评估，以确定培训活动的有效性和改进点。他们可能会使用问卷调查、测试、观察等方法来评估培训的成效，并根据评估结果提出改进建议。

6. 跟进和支持：内训师会与培训参与者进行跟进和支持，帮助他们将所学知识和技能应用到实际工作中。他们可能提供个别辅导、答疑解惑，并与参与者保持沟通，以促进学习的持续和应用的成功。

7. 培训需求识别：内训师会密切关注组织变化和员工发展需求，识别新的培训需求。他们会与管理层和人力资源部门合作，确保培训计划与组织目标和策略保持一致。

总的来说，内训师在组织内部发挥着重要的角色。他们帮助提高员工的知识和技能水平，增强组织的竞争力，促进员工职业发展，同时也为公司提供了一个培养人才和保持组织活力的重要渠道。




# 第一章

## 成人体验式学习特点

**库伯学习圈** 

- 具体体验
- 反思性观察
- 抽象概念化
- 积极实验

![](https://niuery.com/static/img/435a1ec47e7577f8749716294b711579.image.png)
## 成人学习特点

1. **注意力集中不易长时间维持**

   - 连续的讲授不超过20分钟

   - 每隔二十分钟提供一个小高潮
     - 讲故事
     - 提问题
     - 举手表决
     - 给予承诺
     - 引人发笑
     - 不同寻常的数据
     - 游戏活动
     - 使用辅助工具

   - 每隔二十分钟，做一个小总结

   - 每隔二十分钟可以暂时休息

2. **目的性强，以解决问题为核心**
   - 课程设计，目标解决问题
   - PPT或课件在三页内，能表达出学习后的收益
   - 授课过程中，链接现实，授课内容跟学员目标紧密相连
3. **遗忘速度快**
   - 艾宾浩斯遗忘曲线
   - 成人学习效果金字塔（效果递增）
     - level1 听讲座（5%）
     - level2 阅读 （10%）
     - level3 视听，示范 （20~35%）
     - level4 小组讨论，动手练习 （50~79%）
     - level5 教他人，立即使用 （80%）



# 第二章

## 内训师角色认知

1. **企业培训的重要性**：

   唯一持久的优势，是有能力比竞争对手学习的更快。 ---彼得·圣吉

   光是吸收知识，资讯，并不是学习，真正的学习必定是修正行为，也就是修行，修炼之意。 --- 彼得·圣吉

   当需要机会改变时，应促使企业与其成员随之成长发展，这意味着每个企业都应该成为学习型组织，与教学型组织，训练与发展是永无止境的。--- 彼得·布鲁克

2. **企业培训的必要性**

   没有**艰苦训练**的士兵没有**战斗力**。没有**教育培训**的员工没有**生产力**。

3. **内训师对企业的重要性**

   - 核心竞争力（高）
   - 人才 （中）
   - 有效的培训系统 （低）
     - 讲师体系 --- 内训师的重要体现
     - 制度体系
     - 课程体系
     - 评估体系

4. **为什么要成为兼职内训师**

   - 教学相长
     - 系统梳理所学知识
     - 提升自我能力（快速学习，演讲，教练技术等）

   - 发展机会
     - 提升个人威信与影响力
     - 内训师是企业中各级管理人员的发源地

5. **内训师的三重角色**

   - 专业课程设计（编）
   - 课堂活动组织（导）
   - 课程内容表达（演）
   
6. **内训师的职责（KSA）** --- 目的是改变学员行为，提升组内绩效

   - 传播知识（Knowledge）
   - 训练技能（Skills）
   - 转变态度（Attitude）

7. **内训师的优劣势**

   1. 优势
      - 熟悉企业内部情况
      - 自身成长树立榜样
      - 培训成本低
      - 容易控制
   2. 劣势
      - 近亲繁殖
      - 选择范围限制
      - 没有权威性
      - 受训者热情不够


# 第三章



## 培训项目实施步骤

**培训项目实施步骤**

1. 需求分析
2. 目标设定
3. 策划开发
4. 培训实施
5. 评估考核
6. 效果转化

**培训需求分析方法**

- 问卷调查
- 关键人物访谈
- 专家会议
- 记录，报告法
- 环境扫描法
- 绩效差距分析法

**目标设定**

设定培训目标的原则SMART：

- 具体的，明确的  --- Specific
- 可量化的 --- Measurable
- 可达成的 --- Achievable
- 相关的 --- Relevant
- 有时间限制的 --- Time-Based

**策划开发**

课程策划“五线谱”法

- 时间线 --- 20分钟
- 内容线 --- 成人学习特点
- 目的线 --- 了解培训
- 方法线 --- 讲授法，提问
- 资源线 --- 成人学习16条原理，艾宾浩斯遗忘曲线，学习效果金字塔

**培训实施**

1. 常见的培训方式

   | 培训方式  |                 目的                  |                             应作                             |                       避免                        |
   | :-------: | :-----------------------------------: | :----------------------------------------------------------: | :-----------------------------------------------: |
   | 传统讲授  |               提供信息                |                          举例和说明                          |     不要连续讲授超过30分钟而不做其他任何活动      |
   | 分组讨论  |     让学员彼此交流经验并互相学习      |  鼓励人人参与/以引导式问题发起讨论/以某种形式的总结结束讨论  |             1~2人垄断/未到时间就停止              |
   | 头脑风暴  | 在短时间里激发出各种想法/激发出创造性 |              在开始前回顾基本规则/鼓励人人参与               | 在头脑风暴法完成前便开始讨论/批判轻视任何一种想法 |
   | 视频教学  |        直观简洁地激发学习动力         |                准备播放条件/视频剪辑/贴近主题                |              时间太长/图像声音不清晰              |
   | 案例分析  |         引发思考/映射现实场景         | 给与明确指导/提供充足信息与背景/突出案例中与课程要相关的因素，变量/指出案例与实际工作相似之处 |            花费时间讲述与主题无关的点             |
   | 角色扮演  |             模拟实际工作              | 让学员重温了解游戏规则/给学员5分组筹划后试演/确保所有学员能看，听到扮演/鼓励自愿者 |                   强迫学员参演                    |
   | 游戏/活动 |        鼓励学员自学和互相学习         | 给与清楚的指导/明确描述期望的结果/确保有足够时间做完/充分解释 |                                                   |
   | 现场练习  |               活学活用                |             提前准备/现场发放/准备答案/自我评分              |                                                   |

   

2. 课程策划培训师自查表

   1. 我为何被邀请来上这堂训练课？
   2. 受训学员的情况我了解多少？
   3. 我准备用什么样的方式开始训练？
   4. 我确定了一个还是几个主题？
   5. 我是否有充足的资料做支持？
   6. 本次训练我准备了哪几种培训方式？
   7. 训练过程中是我讲的多还是学员练的多？
   8. 我对时间的掌控是否恰到好处
   9. 训练结束后是否能让学员感到意犹未尽
   10. 是否要求作业？

3. 教案策划注意事项

   - 学习重点最多不能超过5个，以3个为佳

   - 预留休息时间

   - 特定时间段

   - 留出时间答疑或处理突发问题

**效果评估** 

柯氏四级培训评估模式

- Level1 反应评估（Reaction）--- 评估被培训者的满意程度
- Level2 学习评估（Learning）--- 测定被培训者的学习收获程度（考试，提问，作业，练习）
- Level3 行为评估（Behavior）--- 考察被培训者的知识运用程度
- Level4 成果评估（Result）--- 计算培训创出的经济效益

**效果转化**

培训成果的转化

- 制定行动计划
- 培训内容与实际工作结合
- 坚持后继学习
- 提供培训的后续支持
- 使用绩效辅助
- 营造支持环境

# 第四章

## PPT教材的制作原则之一 ---  KISS

keep it simple and stupid（保持简单，通俗易懂）

1. 高桥征义，超大字演示法 
2.  提炼关键词

   - 大标题表达中心思想

   - 小标题本段关键词
3. 信息量太大的解决办法
   - 充分利用备注
   - 拆分多个页面
   - 要点逐条显示

## PPT教材的制作原则二 --- 视觉化

视觉化 ，把概念或数据翻译成图（图片/图表）

 材料变教材：分析文字 -> 套用图表 -> 运用图片

## 课堂呈现技巧

1. **控制紧张情绪**

   - 生理舒缓法：肌肉放松，呼吸调适
   - 心理诱导法：回想喜悦，预演成功
   - 自我解脱法：放开自我，身心投入
   - 超量准备法：准备充分，大量演练

2. **开场**

333原则：3s第一映像，3min开场交流，才会有3h，3d，甚至3y的接触交流

   1. 简短的自我介绍
   2. 课堂规划，调动参与的气氛
   3. 简述大纲，引起兴趣
   4. 简述课程目标，明确学习方向
   5. 简述课程收益，抛出利益点

   其他开场方法

   1. 提问
   2. 讲故事

3. **主体内容授课技巧**

   - 言辞内容（7%）
   - 声音（38%）音调，语气用词，说话速度，音量
   - 形象（55%）仪态，表情，视线，手势，态度，衣服色彩

4. **内训师的语言**

   - 简洁，通俗，明快，有节奏
   - 多用积极美好的字眼
   - 严谨，逻辑严密

5. **内训师的声音**

   - 语调
   - 重音
   - 停顿
   - 语速
   - 语气

6. **如何目光接触**

   - 目光接触3~5s
   - 照顾到所有人
   - 不要形成规律
   - 自然

7. **肢体语言**

   - 手势
   - 面部表情
   - 步伐
   - 肢体动作
   - 其他令人分心的动作

8. **问题的功用**

   - 使沉默的人发言
   - 带动经验分享
   - 提出尚未讨论的要点
   - 提升注意资料的来源
   - 评估一项看法的凝聚力
   - 放置一些人垄断发言
   - 引导结束某一项议题的讨论

9. **精彩点评技巧**

   1. 总体概括 （总的来看...）
   2. 价值点（值得欣赏的是....）
   3. 薄弱点（遗憾的是.../但是...）
   4. 示范（这样会更好些...）
   5. 小结（希望如此...）

   点评原则：**针对性准确**，**综合性全面**，**超越性精辟**。

10. **辨别消极学员**

    - 摇头
    - 短暂闭眼
    - 揉鼻子或鼻梁
    - 摘下眼镜
    - 频繁喝水
    - 腿抖动
    - 打哈欠
    - 伸懒腰
    - 局部小按摩
    - 手下垂并晃动
    - 与同桌聊两句
    - 凝视一点不动
    - 无目的的翻阅资料
    - 频繁看表

11. **处理消极学员**

    停顿，沉默，重复，异声

    - 学员走神
    - 课堂私语
    - 学员睡觉
    - 课堂混乱

    冷静回应，建立同盟

    - 有意抬杠
    - 恶意挑衅

    提供机会，虚心请教

    - 遭遇高手

12. **答问阶段技巧**

    - 直视提问题的人，确认一遍问题
    - 确定范围
    - 将复杂问题分步/分块回答
    - 确定自己回答真实可靠
    - 鼓励别人回答
    - 避免回答篇幅过长

13. **结束**

    - 总结主题思想
    - 激励行为，展望未来
    - 引经据典，总结发言
    - 跳出常规，不落俗套

14. **内训师的特性**

    - 有教学的愿望
    - 深广的专业知识与行业背景
    - 表达能力及相关的培训技巧
    - 耐心
    - 幽默感
    - 其他品质，如敏锐，擅长倾听，乐意分享，不歧视学员，i灵活把握学习进度
    - 培训的热情
    - 知道培训能解决的问题及不能解决的问题

职业软技能 --- 内训师

# 引言
上一篇文章[UI自动化 --- 微软UI Automation](https://niuery.com/post/69)中，介绍了UI Automation能够做什么，且借助 Inspect.exe 工具完成了一个模拟点击操作的Demo，文章结尾也提出了自己的一些想法，想要借助UI Automation做一个UI自动化测试平台。想法毕竟是想法，还是得落地实践，一步一步来。

本篇文章内容详细学习UI Automation 的基础知识。


# UI Automation 基础
上一篇文章中提到 UIAutomation 通过五个组件实现编程访问：
- UI Automation tree（UI自动化树）
- UI Automation elements（UI自动化元素）
- UI Automation properties(UI自动化属性)
- Control patterns（控件模式）
- UI Automation events（UI自动化事件）

接下来一一学习，以下内容翻译自微软官方文档（https://learn.microsoft.com/en-us/dotnet/framework/ui-automation/ui-automation-fundamentals）。

## UI Automation tree（UI自动化树）
UI自动化树可以通过过滤来创建仅包含特定客户端相关的 `AutomationElement` 对象的视图。这种方法允许客户端根据其特定需求自定义通过UI自动化呈现的结构。

客户端有两种方式来自定义视图：通过作用域和过滤。作用域是定义视图的范围，从一个基本元素开始：例如，应用程序可能只想查找桌面的直接子元素，或者某个应用程序窗口的所有后代元素。过滤是定义要包含在视图中的元素类型。

UI自动化提供程序通过在元素上定义属性来支持过滤，包括 `IsControlElementProperty` 和 `IsContentElementProperty` 属性。

UI自动化提供了三个默认视图：**原始视图**，**控件视图**，**内容视图**。

这些视图是根据执行的过滤类型定义的；任何视图的作用域由应用程序定义。此外，应用程序还可以对属性应用其他过滤器；例如，只在控件视图中包含已启用的控件。


### 原始视图（Raw View）

UI自动化树的原始视图是以桌面为Root的 `AutomationElement` 对象的完整树。原始视图紧密遵循应用程序的本机编程结构，因此是最详细的可用视图。它也是其他视图构建的基础。由于该视图依赖于底层UI框架，因此WPF按钮的原始视图将与Win32按钮的原始视图不同。

通过在不指定属性的情况下搜索元素或使用 `RawViewWalker` 浏览树，可以获得原始视图。

```csharp
AutomationElement elementNode = TreeWalker.RawViewWalker.GetFirstChild(AutomationElement.RootElement);
```
### 控件视图（Control View）
UI自动化树的控件视图简化了辅助技术产品描述UI给终端用户并帮助终端用户与应用程序交互的任务，因为它与终端用户感知的UI结构紧密对应。

控件视图是原始视图的一个子集。它包括原始视图中的所有UI项，这些项被用户理解为可交互，或对UI中的控件的逻辑结构起作用。

对UI逻辑结构有贡献但本身不可交互的UI项例如有列表视图的标题、工具栏、菜单和状态栏。

仅用于布局或装饰目的的非交互项不会在控件视图中显示。例如，一个本身不包含任何信息，仅用于布局对话框中的控件的面板。

控件视图中可见的非交互项例如有包含信息的图形和对话框中的静态文本。

控件视图中包含的非交互项不能接收键盘焦点。

通过搜索具有 `IsControlElement` 属性设置为 `true` 的元素，或使用 `ControlViewWalker` 浏览树，可以获得控件视图。

```csharp
AutomationElement controlViewElementNode = TreeWalker.ControlViewWalker.GetFirstChild(AutomationElement.RootElement);
```
### 内容视图（Content View）

UI自动化树的内容视图是控件视图的一个子集。

它包含传达用户界面中真实信息的UI项，包括可以接收键盘焦点的UI项以及一些不是UI项上的标签的文本。例如，下拉组合框中的值将出现在内容视图中，因为它们代表终端用户正在使用的信息。

在内容视图中，组合框和列表框都被表示为一组UI项，其中可以选择一个或多个项。

在内容视图中，一个始终处于打开状态，而另一个可以展开和折叠的事实是无关紧要的，因为它旨在显示呈现给用户的数据或内容。

通过搜索具有 `IsContentElement` 属性设置为 `true` 的元素，或使用 `ContentViewWalker` 浏览树，可以获得内容视图。

```csharp
AutomationElement ContentViewElementNode = TreeWalker.ContentViewWalker.GetFirstChild(AutomationElement.RootElement);
```

## UI Automation elements（UI自动化元素）

UI自动化元素可以表示各种用户界面元素，例如窗口、按钮、文本框、复选框、列表框、菜单等等。每个元素都有一个唯一的标识符，称为 `AutomationID`，它可以用来定位和操作元素。例如模拟用户点击、输入文本、选择选项、获取界面元素属性等。


## UI Automation properties（UI自动化属性）

每个属性都由一个数字和一个名称标识。属性的名称仅用于调试和诊断。提供程序使用数字ID来标识传入的属性请求。然而，客户端应用程序只使用 **AutomationProperty** 来标识它们希望检索的属性，**AutomationProperty** 封装了数字和名称。

表示特定属性的 **AutomationProperty** 对象可作为各种类中的字段使用。出于安全原因，UI自动化提供程序从 `Uiautomationtypes.dll` 中包含的一组单独的类中获取这些对象。

### 根据ID分组
以下表格按包含 `AutomationPropertyIDs` 的类对属性进行了分类。

 

|属性的种类										|	客户端从中获取 ID					|		提供程序从中获取 ID    |
| --- | --- |---|
|所有元素共有的属性（请参阅下表）				|	AutomationElement					|		AutomationElementIdentifiers           |
|停靠窗口的位置									|	DockPattern							|		DockPatternIdentifiers                 |
|可展开和折叠的元素的状态						|	ExpandCollapsePattern				|		ExpandCollapsePatternIdentifiers       |
|网格中某项的属性								|	GridItemPattern						|		GridItemPatternIdentifiers             |
|网格的属性										|	GridPattern							|		GridPatternIdentifiers                 |
|具有多个视图的元素的当前和支持的视图			|	MultipleViewPattern					|		MultipleViewPatternIdentifiers         |
|在一定范围的值内移动的元素（如滑块）的属性		|	RangeValuePattern					|		RangeValuePatternIdentifiers           |
|滚动窗口的属性									|	ScrollPattern						|		ScrollPatternIdentifiers               |
|可选择的某项（如列表中的某项）的状态和容器		|	SelectionItemPattern				|		SelectionItemPatternIdentifiers        |
|包含选择项的控件的属性							|	SelectionPattern					|		SelectionPatternIdentifiers            |
|表中某项的列和行标题							|	TableItemPattern					|		TableItemPatternIdentifiers            |
|表的列和行标题以及方向							|	TablePattern						|		TablePatternIdentifiers                |
|切换控件的状态									|	TogglePattern						|		TogglePatternIdentifiers               |
|可移动、旋转、或调整大小的元素的功能			|	TransformPattern					|		TransformPatternIdentifiers            |
|具有值的元素的值和读/写功能					|		ValuePattern					|			ValuePatternIdentifiers            |
|窗口的功能和状态								|	WindowPattern						|		WindowPatternIdentifiers               |

### 根据类别分组
这里只列举根据标识分组，除此之外还有按显示特征分组，按元素类型分组，按交互类型分组，按对模式的支持分组等，详见微软官方文档。


| 属性标识符 |属性访问  |
| --- | --- |
|AutomationIdProperty		|AutomationId         |
|ClassNameProperty			|ClassName            |
|FrameworkIdProperty		|	FrameworkId       |
|LabeledByProperty			|LabeledBy            |
|NameProperty				|Name                 |
|ProcessIdProperty			|ProcessId            |
|RuntimeIdProperty			|GetRuntimeId         |
|NativeWindowHandleProperty	|NativeWindowHandle   |



## Control patterns（控件模式）

UI自动化使用控件模式来表示常见的控件行为。例如，您可以使用 `Invoke` 控件模式来处理可以调用的控件（如按钮），并使用 `Scroll` 控件模式来处理带有滚动条的控件（如列表框、列表视图或组合框）。由于每个控件模式代表着一个独立的功能，它们可以组合在一起描述特定控件支持的完整功能集。

控件模式支持定义控件中可用的离散功能所需的方法、属性、事件和关系。

- UI自动化元素与其父级、子级和同级之间的关系描述了元素在UI自动化树中的结构。

- 方法允许UI自动化客户端操作控件。

- 属性和事件提供有关控件模式功能以及控件状态的信息。

控件模式与UI的关系类似于接口与组件对象模型（COM）对象的关系。在COM中，您可以查询对象以了解它支持哪些接口，然后使用这些接口访问功能。在UI自动化中，UI自动化客户端可以询问控件支持哪些控件模式，然后通过支持的控件模式公开的属性、方法、事件和结构与控件进行交互。例如，对于多行编辑框，UI自动化提供程序实现了 `IScrollProvider`。当客户端知道 `AutomationElement` 支持 `ScrollPattern` 控件模式时，它可以使用该控件模式公开的属性、方法和事件来操作控件或访问有关控件的信息。

| 控件模式类 |提供程序接口  |说明|
| --- | --- | --- |
|DockPattern				|		IDockProvider			|		用于可在停靠容器中停靠的控件。 例如，工具栏或工具调色板。                                                                                                             |
|ExpandCollapsePattern		|	IExpandCollapseProvider		|	用于可展开或折叠的控件。 例如，应用程序中的菜单项，如 “文件” 菜单。                                                                                                       |
|GridPattern				|		IGridProvider			|		用于支持网格功能（如调整大小和移动到指定单元格）的控件。 例如 Windows 资源管理器中的大图标视图或 Microsoft Word 中的不带标头的简单表格。                              |
|GridItemPattern			|		IGridItemProvider		|		用于在网格内具有单元格的控件。 单个单元格应支持 GridItem 模式。 例如 Microsoft Windows 资源管理器详细信息视图中的每个单元格。                                         |
|InvokePattern				|	IInvokeProvider				|	用于可被调用的控件，如按钮。                                                                                                                                              |
|MultipleViewPattern		|		IMultipleViewProvider	|		用于可在同一组信息、数据或子级的多个表示形式之间切换的控件。 例如，在列表视图控件中，数据可用于缩略图、磁贴、图标、列表或详细信息视图。                               |
|RangeValuePattern			|	IRangeValueProvider			|	用于具有一系列可应用于该控件的值的控件。 例如，包含年份的微调框控件可能具有从 1900 到 2010 的年份范围，而表示月份的另一个微调框控件则会具有从 1 到 12 的月份范围。        |
|ScrollPattern				|	IScrollProvider				|	用于可滚动的控件。 例如，一个控件其所具有的滚动条在控件的可视区域中存在的信息超过了可被显示的信息时，便处于活动状态。                                                     |
|ScrollItemPattern			|	IScrollItemProvider			|	用于一种控件，该控件具有可滚动列表中的各个项。 例如，一个列表控件，该控件具有滚动列表中的各个项，如组合框控件。                                                           |
|SelectionPattern			|	ISelectionProvider			|	用于选择容器控件。 例如，列表框和组合框。                                                                                                                                 |
|SelectionItemPattern		|	ISelectionItemProvider		|	用于选择容器控件中的各个项，如列表框和组合框。                                                                                                                            |
|TablePattern				|	ITableProvider				|	用于具有网格以及标头信息的控件。 例如 Microsoft Excel 工作表。                                                                                                            |
|TableItemPattern			|	ITableItemProvider			|	用于表中的项。                                                                                                                                                            |
|TextPattern				|		ITextProvider			|		用于可公开文本信息的编辑控件和文档。                                                                                                                                  |
|TogglePattern				|	IToggleProvider				|	用于在其中可切换状态的控件。 例如，复选框和可选中的菜单项。                                                                                                               |
|TransformPattern			|	ITransformProvider			|	用于可调整大小、移动和旋转的控件。 Transform 控件模式通常用于设计器、窗体、图形编辑器和绘图应用程序。                                                                     |
|ValuePattern				|	IValueProvider				|	允许客户端在不支持某个值范围的控件上获取或设置值。 例如，日期时间选择器。                                                                                                 |
|WindowPattern				|	IWindowProvider				|	向 Microsoft Windows 操作系统公开特定于窗口的信息（一种基本概念）。 属于窗口的控件示例是顶级应用程序窗口（Microsoft Word、Microsoft Windows 资源浏览器等）、多文档界面 (MDI)子窗口和对话框。|




## UI Automation events（UI自动化事件）
Microsoft UI自动化事件是屏幕阅读器和屏幕放大器等辅助技术的关键功能。这些UI自动化客户端跟踪由UI自动化提供程序触发的事件，当UI中发生某些情况时，它们使用这些信息通知终端用户。

通过允许提供程序应用程序有选择地触发事件，根据是否有客户端订阅这些事件，或者如果没有客户端监听任何事件，则可以完全不触发事件，从而提高效率。

UI 自动化事件有以下类型。更详细内容请阅读微软官方文档。

| 事件 |  说明|
| --- | --- |
|属性更改		|当 UI 自动化元素上的某个属性或控件模式更改时引发。 例如，如果客户端需要监视应用程序的复选框控件，它可以注册来侦听 ToggleState 属性上的属性更改事件。 选中或取消选中该复选框控件时，提供程序会引发事件且客户端会采取必要的操作。|
|元素操作		|当来自最终用户或编程活动的 UI 结果出现更改时引发；例如，单击或通过 InvokePattern 调用一个按钮。                                                                                                                                |
|结构更改		|在 UI 自动化树的结构更改时引发。 当桌面上有新 UI 项变得可见、隐藏或删除时，结果便发生更改。                                                                                                                                    |
|全局桌面更改	|当与客户端相关的的全局操作发生时引发，例如当焦点从一个元素转换到另一个元素、或窗口关闭时。

## 结尾

文中只列举了部分内容，更详细内容请阅读微软官方文档，文档还是很详细的，比较难受的地方就是示例代码太少，可能需要自己发掘了。

总的来说，我觉得一些简单UI自动化测试执行起来应该是没问题的，但是一些自定义控件，或者复杂操作流程的，可能就需要费些脑筋了，费脑筋了还不一定能搞定。

搞搞看吧。

>参考链接
>
>https://learn.microsoft.com/en-us/dotnet/framework/ui-automation/using-ui-automation-for-automated-testing