## 引言

自动化测试平台的意义就三个字 --- 稳定性。

无论是接口自动化测试，还是UI自动化测试，目的就是为了提高产品的稳定性，保证用户体验。

那常见的接口自动化测试比如有 `Postman` ，`SoapUI`，`JMeter` 等等。这一类网上的资料就太多太多了。本篇内容主要想讨论的是UI自动化测试，我搜集了一下常见的UI自动化测试平台：
- **Selenium**：Selenium是开源且免费的，使用非常广泛的Web应用程序自动化测试框架，它既支持多种语言的脚本驱动测试，也支持记录与回放的方式测试。
- **Appium**：Appium是一个开源免费的移动应用程序自动化测试框架，也支持多种语言的脚本驱动测试。
- **Katalon Studio**： Katalon Studio是一款免费的UI自动化测试工具，适用于Web、移动和API测试。它基于Selenium和Appium，并提供了图形化界面和内置的测试功能。
- **TestComplete**：TestComplete是一款功能强大的商业UI自动化测试工具，适用于Web、桌面和移动应用程序。它提供了多种脚本语言和图形化界面，以及灵活的对象识别和回放功能。
- **Ranorex**: Ranorex是一款商业UI自动化测试工具，适用于Web、桌面和移动应用程序。它提供了易于使用的录制和回放功能，支持多种编程语言。


从上面的数据中其实不难发现，对于桌面应用的UI自动化测试，上述框架或工具要么免费但是仅支持Web应用，要么就是商业化工具，一言难尽啊。

所以这就提到了我们的主题了 --- UIAutomation。

## UIAutomation 介绍

来看一下微软官方对此的介绍 [UIAutomation](https://learn.microsoft.com/en-us/dotnet/framework/ui-automation/using-ui-automation-for-automated-testing):

Microsoft UI Automation是适用于Microsoft Windows的辅助功能框架。它满足了辅助技术产品和自动化测试框架的需求，通过提供对用户界面（UI）信息的编程访问来实现。此外，UI Automation还使控件和应用程序开发人员能够使其产品具有辅助功能。

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


里边提到了，使用编程访问可以通过代码模仿由传统鼠标和键盘输入展开的任何交互和体验，`UIAutomation` 通过五个组件实现编程访问：
- UI Automation tree（UI自动化树）
- UI Automation elements（UI自动化元素）
- UI Automation properties(UI自动化属性)
- Control patterns（控件模式） 
- UI Automation events（UI自动化事件）

如下图所示：
![image.png](https://niuery.com/static/img/bbcdcc3b0dc0ebd26870354654cfee5d.image.png)

最后列出了测试应用程序中实现UI自动化的步骤：

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

## 辅助工具介绍
步骤中提到了一个工具 --- **Inspect.exe** ，该工具是一个图形用户界面 (GUI) 应用程序，可用于收集用于提供程序和客户端开发和调试的 UI 自动化信息，它包含在 Windows SDK 中。

所以要使用**Inspect.exe**去查询控件的 `AutomationIdProperty`，必须安装Windows SDK。

然后可以直接使用Everything直接搜索 Inspect.exe ，可以看到 SDK 安装目录下，分别有x64，x86，arm64，arm四个，我们一般选择 x64 就可以。

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

然后使用该工具可以找到目标应用的控件，如下图，找到了按钮的`AutomationID` 就可以进行编码模拟点击。


![455a6c56107d.png](https://niuery.com/static/img/455a6c56107d798f9dca491e5cce8d3e.455a6c56107d.png)

## 小试牛刀
接下来编写代码测试一下：
1. 创建目标程序，一个WPF程序，放置一个TextBox输入框，命名为 `textbox1`，再放置一个按钮，命名为 `button1`,`button1`点击后弹窗提示“UIAutomation按钮测试”。
2. 接下来创建测试程序，创建一个控制台程序，使用 `UIAutomation API` 执行在点击`button1`在 `textbox1`文本框输入"UIAutomation按钮测试"后缀时间。
3. 使用**Inspect.exe**找到目标程序的的进程ID和控件的`AutomationID`。输入到测试程序中，看执行结果。

测试控制台程序代码如下：

```csharp
using System;
using System.Diagnostics;
using System.Windows.Automation;

public class ProcessButtonClickAutomation
{
    public static void Main()
    {
        Console.WriteLine("请输入目标进程ID:");
        var targetProcessId = Console.ReadLine();
        Console.WriteLine("请输入目标控件AutomationId:");
        var automationId = Console.ReadLine();

        // 根据进程ID查找进程
        Process targetProcess = FindProcessById(int.Parse(targetProcessId));

        if (targetProcess != null)
        {
            // 查找进程的主窗口句柄
            IntPtr mainWindowHandle = targetProcess.MainWindowHandle;

            if (mainWindowHandle != IntPtr.Zero)
            {
                // 使用主窗口句柄获取AutomationElement
                AutomationElement mainWindowElement = AutomationElement.FromHandle(mainWindowHandle);

                // 查找按钮元素，根据需要修改按钮查找条件
                PropertyCondition condition = new PropertyCondition(AutomationElement.AutomationIdProperty, automationId);
                AutomationElement buttonElement = mainWindowElement.FindFirst(TreeScope.Descendants, condition);

                if (buttonElement != null)
                {
                    // 获取按钮元素的InvokePattern
                    InvokePattern invokePattern = buttonElement.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern;

                    if (invokePattern != null)
                    {
                        // 模拟按钮点击操作
                        invokePattern.Invoke();
                        Console.WriteLine("按钮已被点击  " + DateTime.Now);
                    }
                    else
                    {
                        Console.WriteLine("按钮不可用");
                    }
                }
                else
                {
                    Console.WriteLine("找不到按钮元素");
                }
            }
            else
            {
                Console.WriteLine("找不到进程的主窗口");
            }
        }
        else
        {
            Console.WriteLine("找不到指定的进程");
        }
        Console.WriteLine("执行完成~");

        Console.ReadLine();
    }

    // 根据进程ID查找进程
    public static Process FindProcessById(int processId)
    {
        try
        {
            Process process = Process.GetProcessById(processId);
            return process;
        }
        catch (ArgumentException)
        {
            return null;
        }
    }
}
```
使用**Inspect.exe**可以看到目标WPF程序的 `ProcessID = 24984` ，按钮控件的 `AutomationId = button1`

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

在控制台输入 `ProcessID` 和 `AutomationId` 可以看到结果测试程序执行结束后，目标WPF程序的文本框同时刷新。

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

## 写在结尾

UI Automation说是框架，我觉得更像是一组API，只是提供了你能够做自动化测试的基本能力，如果想要搭建一个桌面应用的UI自动化测试平台，那需要做的还有很多。比如你需要实现脚本支持，需要实现执行报告和日志，需要实现数据驱动测试，甚至需要支持持续集成和持续交付（CI/CD）流程中自动执行UI自动化测试。

现在我想搭建一个基于 UI Automation 的桌面应用的UI自动化测试平台，现在只是有一个大体思路：
- UI Automation 提供桌面应用自动化测试的基本能力。
- Roslyn 编译器平台提供脚本支持。
- 执行报告和日志在封装UI Automation API的过程中，就可以添加进去了
- 数据驱动测试就可以在脚本中完成。
- 最后一点，持续集成和持续交付可以交给Jenkins

还是文章开头说到的，于桌面应用的UI自动化测试，现有框架或工具要么免费但是仅支持Web应用，要么就是商业化工具，所以想自己整一个，想法和方案都有了，至于可以做成什么样，那就拭目以待吧。

不了解 Roslyn 编译器平台的，可以看我之前的两篇文章
- .Net 编译器平台 --- Roslyn（https://niuery.com/post/67）
- .Net 编译器平台--- Roslyn Scripting APIs（https://niuery.com/post/68）

> 参考链接
> 
>Using UI Automation for Automated Testing： https://learn.microsoft.com/en-us/dotnet/framework/ui-automation/using-ui-automation-for-automated-testing
>
>.Net 编译器平台 --- Roslyn（https://niuery.com/post/67）
>.Net 编译器平台--- Roslyn Scripting APIs（https://niuery.com/post/68）

UI自动化 --- 微软UI Automation

# 引言

上一篇中[.Net 编译器平台 --- Roslyn](https://niuery.com/post/67)，介绍了Roslyn的各项功能，包括公开API，使用语法，使用语义，使用工作区等功能。

那么回到上一篇中提到的问题，实现类似这样的功能（以下代码为伪代码）：

```csharp
string scriptText = "int a = 1;int b = 2; return a+b ;";

var result = Script.Run(scriptText);
```
就用到了上一篇提到的 **Scripting APIs**，还是先了解一下Roslyn提供的 Scripting APIs 有哪些。



官方文档（https://github.com/dotnet/roslyn/blob/main/docs/wiki/Scripting-API-Samples.md） 还是英文版，还是先将他翻译为中文，以下内容为译文。




# Scripting APIs Samples

脚本 API 可以让 .NET 应用程序实例化一个 C# 引擎，并针对由宿主提供的对象执行代码片段。以下是使用脚本 API 并进行一些常见示例的入门示例。您也可以查看脚本 API 的源代码。

请注意，作为一个语言模型，我无法提供实时的源代码示例或链接到具体的源代码。但是，您可以参考 Microsoft 的官方文档和示例来了解如何使用脚本 API 并查看相关源代码。

## 支持的平台

脚本 API 需要桌面版 .NET Framework 4.6+ 或 .NET Core 1.1（自 Roslyn v2.0.0-rc3、Visual Studio 2017 RC3 起支持）。

脚本 API 无法在通用 Windows 应用程序和 .NET Native 中使用，因为应用程序模型不支持在运行时加载生成的代码。

## 开始准备
安装 Scripting API NuGet 包：

```
Install-Package Microsoft.CodeAnalysis.CSharp.Scripting
```
## 示例代码

以下示例代码中需要添加引用 `using Microsoft.CodeAnalysis.CSharp.Scripting; `

应用场景：
- 评估一个C#表达式（Evaluate a C# expression）
- 评估一个C#表达式（强类型）（Evaluate a C# expression(strongly-typed)）
- 带错误处理的评估C#表达式（Evaluated a C# expression with error handling）
- 添加引用（Add references）
- 添加命名空间和类型导入（Add namespace and type imports）
- 为脚本参数化（Parameterize a script）
- 创建和构建一个C#脚本，并多次执行（Create&build a C# script and execute it multiple times）
- 创建一个指向脚本的委托（Create a delegate to a script）
- 运行一个C#代码片段并检查定义的脚本变量（Run a C# snippet and inspect defined script variables）
- 将代码片段链接成一个脚本（Chain code snippets to form a script）
- 从先前状态继续执行脚本（Continue script execution from a previous state）
- 创建和分析一个C#脚本（Create and analyze a C# script）
- 自定义程序集加载（Customize assembly loading）


### 评估一个C#表达式（Evaluate a C# expression）


```csharp
object result = await CSharpScript.EvaluateAsync("1 + 2");
```

### 评估一个C#表达式（强类型）（Evaluate a C# expression(strongly-typed)）

```csharp
int result = await CSharpScript.EvaluateAsync<int>("1 + 2");
```

### 带错误处理的评估C#表达式（Evaluated a C# expression with error handling）

```csharp
try
{
    Console.WriteLine(await CSharpScript.EvaluateAsync("2+2"));
}
catch (CompilationErrorException e)
{
    Console.WriteLine(string.Join(Environment.NewLine, e.Diagnostics));
}
```

### 添加引用（Add references）

```csharp
var result = await CSharpScript.EvaluateAsync("System.Net.Dns.GetHostName()", 
ScriptOptions.Default.WithReferences(typeof(System.Net.Dns).Assembly)); 
```

### 添加命名空间和类型导入（Add namespace and type imports）
在下面的代码中，`WithImports("System.IO") `将 `using System.IO`; 添加到脚本选项中，使得可以在脚本代码中直接引用 `System.IO` 命名空间的类型，而无需使用限定符。
```csharp
var result = await CSharpScript.EvaluateAsync("Directory.GetCurrentDirectory()"), 
                                ScriptOptions.Default.WithImports("System.IO"));
```
同样地，`WithImports("System.Math")` 将 `using static System.Math`; 添加到脚本选项中，使得可以在脚本代码中直接引用 `System.Math` 类型的成员，而无需使用限定符。
```csharp
var result = await CSharpScript.EvaluateAsync("Sqrt(2)", 
                                ScriptOptions.Default.WithImports("System.Math"));
```

### 为脚本参数化（Parameterize a script）

```csharp
public class Globals
{
    public int X;
    public int Y;
}

var globals = new Globals { X = 1, Y = 2 };

Console.WriteLine(await CSharpScript.EvaluateAsync<int>("X+Y", globals: globals));
```

:::tip{title="提示"}
目前，Globals 类型必须在从文件加载的程序集中定义。如果程序集在内存中（包括在交互式窗口中执行示例时），脚本将无法访问该类型。请参阅此处的问题。
:::
### 创建和构建一个C#脚本，并多次执行（Create&build a C# script and execute it multiple times）

```csharp
var script = CSharpScript.Create<int>("X*Y", globalsType: typeof(Globals));

script.Compile();

for (int i = 0; i < 10; i++)
{
    Console.WriteLine((await script.RunAsync(new Globals { X = i, Y = i })).ReturnValue);
} 
```

### 创建一个脚本的委托（Create a delegate to a script）
该委托不会保持编译资源（语法树等）处于活动状态。
```csharp
var script = CSharpScript.Create<int>("X*Y", globalsType: typeof(Globals));

ScriptRunner<int> runner = script.CreateDelegate();

for (int i = 0; i < 10; i++)
{
    Console.WriteLine(await runner(new Globals { X = i, Y = i }));
} 
```

### 运行一个C#代码片段并检查定义的脚本变量（Run a C# snippet and inspect defined script variables）

```csharp
var state = await CSharpScript.RunAsync<int>("int answer = 42;");

foreach (var variable in state.Variables)
     Console.WriteLine($"{variable.Name} = {variable.Value} of type {variable.Type}");
```

### 将代码片段链接成一个脚本（Chain code snippets to form a script）

```csharp
var script = CSharpScript.
            Create<int>("int x = 1;").
            ContinueWith("int y = 2;").
            ContinueWith("x + y");

Console.WriteLine((await script.RunAsync()).ReturnValue); 
```

### 从先前状态继续执行脚本（Continue script execution from a previous state）

```csharp
var state = await CSharpScript.RunAsync("int x = 1;");
state = await state.ContinueWithAsync("int y = 2;");
state = await state.ContinueWithAsync("x+y");

Console.WriteLine(state.ReturnValue);
```

### 创建和分析一个C#脚本（Create and analyze a C# script）

```csharp
using Microsoft.CodeAnalysis;

var script = CSharpScript.Create<int>("3");
Compilation compilation = script.GetCompilation();
//do stuff
```
编译（Compilation）提供了对完整的 Roslyn API 集合的访问。

### 自定义程序集加载（Customize assembly loading）

```csharp
using Microsoft.CodeAnalysis.Scripting.Hosting;

using (var loader = new InteractiveAssemblyLoader())
{
    var script = CSharpScript.Create<int>("1", assemblyLoader: loader);
    //do stuff 
}
```

>参考
>
>https://github.com/dotnet/roslyn/blob/main/docs/wiki/Scripting-API-Samples.md

.Net 编译器平台--- Roslyn Scripting APIs 

.Net 编译器平台 --- Roslyn

## 引言

上文[编码技巧 --- 同步锁对象的选定](url)中，提到了在C#中，让线程同步有两种方式：

- 锁（lock、Monitor等）
- 信号量（EventWaitHandle、Semaphore、Mutex）

加锁是最常用的线程同步的方法，就不再讨论，本篇主要讨论使用信号量同步线程。



## WaitHandle介绍

实际上，再C#中 `EventWaitHandle` 、 `Semaphore` 、 `Mutex` 都是抽象类 `WaitHandle` 的派生类，它提供了一组等待信号的方法和属性。如下图：

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

主要包含静态方法 `SignalAndWait()`，`WaitAll()`，`WaitAny()`及一个虚方法`WaitOne()`。下面介绍一个这几个方法。

介绍这些方法之前，先简单介绍一下 `WaitHandle` 的派生类 `EventWaitHandle`，该派生类有两个实现类 `AutoResetEvent` 和 `ManualResetEvent`，其方法列表如下：
![image.png](https://niuery.com/static/img/d536d928b78688801d1cf8b167531da4.image.png)

重点说一下，`Set()`和`Reset()`:

- Set()方法设置事件为有信号状态：当调用 `Set()` 时，它将被设置为终止状态，并允许一个或多个等待该事件的线程继续执行。
- Reset()方法设置事件为无信号状态：当调用 `Reset()` 时，它将被设置为非终止状态，所有想要等待该事件的线程都将被阻塞，直到调用 `Set()` 方法使其变为终止状态。

**注意：这里的有信号，无信号的意思类似于红绿灯，有信号你才能够通行，对于线程来说，有信号意味着可以接着往下运行，无信号则阻塞等待信号。**

接下来的代码段演示皆使用 `AutoResetEvent` 进行演示。

### SignalAndWait()

当调用 `WaitHandle` 的静态方法 `SignalAndWait()` 时，会使得当前线程等待一个 `WaitHandle` 对象的信号，同时设置另一个 `WaitHandle` 对象为有信号状态。当第一个 `WaitHandle` 对象收到信号时，当前线程继续执行，同时第二个 `WaitHandle` 对象变为无信号状态。

```csharp
static AutoResetEvent event1 = new AutoResetEvent(false);
static AutoResetEvent event2 = new AutoResetEvent(false);

static void Main(string[] args)
{
    Thread t1 = new Thread(new ThreadStart(Worker1));
    Thread t2 = new Thread(new ThreadStart(Worker2));

    t1.Start();
    t2.Start();

    Console.ReadLine();
}

static void Worker1()
{
    Console.WriteLine("线程1开始执行……");

    event1.WaitOne(); // 等待事件1的发生

    Console.WriteLine("线程1收到事件1的信号，继续执行……");

    WaitHandle.SignalAndWait(event1, event2); // 发送事件2的信号并等待事件2的发生

    Console.WriteLine("线程1收到事件2的信号，继续执行……");
}

static void Worker2()
{
    Console.WriteLine("线程2开始执行……");

    Thread.Sleep(2000); // 模拟线程2的执行时间

    Console.WriteLine("线程2发出事件1的信号……");

    event1.Set(); // 发送事件1的信号

    Thread.Sleep(2000); // 模拟线程2的执行时间

    Console.WriteLine("线程2发出事件2的信号……");

    WaitHandle.SignalAndWait(event2, event1); // 发送事件1的信号并等待事件1的发生

    Console.WriteLine("线程2收到事件1的信号，继续执行……");
}
```
输出：

```csharp
线程1开始执行……
线程2开始执行……
线程2发出事件1的信号……
线程1收到事件1的信号，继续执行……
线程2发出事件2的信号……
线程2收到事件1的信号，继续执行……
线程1收到事件2的信号，继续执行……
```
### WaitAll()

当调用 `WaitHandle` 的静态方法 `WaitAll()` 时，它可以等待多个WaitHandle对象的信号，直到所有对象都收到信号或等待超时。

```csharp
static AutoResetEvent[] events = new AutoResetEvent[3]
{
    new AutoResetEvent(false),
    new AutoResetEvent(false),
    new AutoResetEvent(false)
};

static void Main(string[] args)
{
    Thread t1 = new Thread(new ThreadStart(Worker1));
    Thread t2 = new Thread(new ThreadStart(Worker2));

    t1.Start();
    t2.Start();

    Console.ReadLine();
}

static void Worker1()
{
    Console.WriteLine("线程1开始执行……");

    WaitHandle.WaitAll(events); // 等待所有事件的发生

    Console.WriteLine("线程1收到所有事件的信号，继续执行……");
}

static void Worker2()
{
    Console.WriteLine("线程2开始执行……");

    Thread.Sleep(2000); // 模拟线程2的执行时间

    Console.WriteLine("线程2发出事件1的信号……");

    events[0].Set(); // 发送事件1的信号

    Thread.Sleep(2000); // 模拟线程2的执行时间

    Console.WriteLine("线程2发出事件2的信号……");

    events[1].Set(); // 发送事件2的信号

    Thread.Sleep(2000); // 模拟线程2的执行时间

    Console.WriteLine("线程2发出事件3的信号……");

    events[2].Set(); // 发送事件3的信号
}
```
输出：

```csharp
线程1开始执行……
线程2开始执行……
线程2发出事件1的信号……
线程2发出事件2的信号……
线程2发出事件3的信号……
线程1收到所有事件的信号，继续执行……
```
### WaitAny()

当调用 `WaitHandle` 的静态方法 `WaitAny()` 时，它可以等待多个WaitHandle对象中的任意一个对象收到信号，直到有一个对象收到信号或等待超时。

```csharp
static AutoResetEvent[] events = new AutoResetEvent[3]
{
    new AutoResetEvent(false),
    new AutoResetEvent(false),
    new AutoResetEvent(false)
};

static void Main(string[] args)
{
    Thread t1 = new Thread(new ThreadStart(Worker1));
    Thread t2 = new Thread(new ThreadStart(Worker2));

    t1.Start();
    t2.Start();

    Console.ReadLine();
}

static void Worker1()
{
    Console.WriteLine("线程1开始执行……");

    WaitHandle.WaitAny(events); // 等待任意事件的发生

    Console.WriteLine("线程1收到任意事件的信号，继续执行……");
}

static void Worker2()
{
    Console.WriteLine("线程2开始执行……");

    var randomIndex = new Random().Next(0, 2);

    Console.WriteLine("线程2发出任意一个事件的信号……");

    events[randomIndex].Set(); //发送任意一个事件的信号
}

```
输出：

```csharp
线程1开始执行……
线程2开始执行……
线程2发出任意一个事件的信号……
线程1收到任意事件的信号，继续执行……
```
### WaitOne()

`WaitOne()`方法上文中其实已经用到了，它就表示阻塞当前线程，等待当前 `WaitHandle` 对象收到信号，直到对象收到信号或等待超时。如果WaitHandle对象收到信号，WaitOne()方法返回true，否则返回false。使用简单就不在贴代码段。

## 派生类的异同

上面已经提到了`EventWaitHandle` 、 `Semaphore` 、 `Mutex` 都是抽象类 `WaitHandle` 的派生类，它们的作用类似，但在使用和实现上有一些不同。下面我们来简单介绍下它们的异同点。

1. EventWaitHandle：

    `EventWaitHandle` 有两种类型：`AutoResetEvent` 和 `ManualResetEvent`。它们的区别在于`AutoResetEvent` 在有信号时只通知一个等待线程，而 `ManualResetEvent` 在有信号时通知所有等待线程。
两者设置为终止状态的方式都是调用 `Set()` 方法。
2. Semaphore

    `Semaphore` 可以用于多个线程之间的资源控制。`Semaphore` 可以控制同时访问共享资源的线程数量。设置为终止状态的方式是调用 `Release()` 方法。
3. Mutex

    `Mutex` 可以用于多个线程之间的互斥访问共享资源。`Mutex` 可以保证同一时间只有一个线程可以访问共享资源。设置为终止状态的方式是调用 `ReleaseMutex()` 方法。

并发编程 --- 信号量线程同步

## 引言

众所周知，使用线程可以极大的提高应用程序的效率和响应性，提高用户体验，但是不可以无节制的使用线程，为什么呢？



## 线程的开销
线程的开销实际上是非常大的，我们从空间开销和时间开销上分别讨论。

### 线程的空间开销
线程的空间开销来自这四个部分：
1. 线程内核对象(Thread Kernel Object)。每个线程都会创建一个这样的对象，它主要包含线程上下文信息，在32位系统中，它所占用的内存在700字节左右。
2. 线程环境块(Thread Environment Block)。TEB包括线程的异常处理链，32位系统中占用4KB内存。
3. 用户模式栈(User Mode Stack),即线程栈。线程栈用于保存方法的参数、局部变量和返回值。每个线程栈占用1024KB的内存。要用完这些内存很简单，写一个不能结束的递归方法，让方法参数和返回值不停地消耗内存，很快就会发生 `OutOfMemoryException` 。
4. 内核模式栈(Kernel Mode Stack)。当调用操作系统的内核模式函数时，系统会将函数参数从用户模式栈复制到内核模式栈。在32位系统中，内核模式栈会占用12KB内存。
### 线程的时间开销
线程的时间开销来自这三个过程：
1. 线程创建的时候，系统相继初始化以上这些内存空间。
2. 接着CLR会调用所有加载DLL的DLLMain方法，并传递连接标志（线程终止的时候，也会调用DLL的DLLMain方法，并传递分离标志)。
3. 线程上下文切换。一个系统中会加载很多的进程，而一个进程又包含若干个线程。但是一个CPU内核在任何时候都只能有一个线程在执行。为了让每个线程看上去都在运行，系统会不断地切换“线程上下文”：每个线程及其短暂的执行时间片，然后就会切换到下一个线程了。
    
    这个线程上下文切换过程大概又分为以下5个步骤：
    - 步骤1进入内核模式。
    - 步骤2将上下文信息（主要是一些CPU寄存器信息）保存到正在执行的线程内核对象上。
    - 步骤3系统获取一个 `Spinlock` ，并确定下一个要执行的线程，然后释放 `Spinlock` 。如果下一个线程不在同一个进程内，则需要进行虚拟地址交换。
    - 步骤4从将被执行的线程内核对象上载入上下文信息。
    - 步骤5离开内核模式。


所以，由于要进行如此多的工作，所以创建和销毁一个线程就意味着代价“昂贵”，即使现在的CPU多核多线程，如无节制的使用线程，依旧会严重影响性能。

## 引入线程池

为了免程序员无节制地使用线程，微软开发了“线程池”技术。简单来说，线程池就是替开发人员管理工作线程。当一项工作完毕时，CLR不会销毁这个线程，而是会保留这个线程一段时间，看是否有别的工作需要这个线程。至于何时销毁或新起线程，由CLR根据自身的算法来做这个决定。

线程池技术能让我们重点关注业务的实现，而不是线程的性能测试。

微软除实现了线程池外，还需要关注一个类型：`BackgroundWorker`。 `BackgroundWorker` 是在内部使用了线程池的技术：同时，在WinForm或WPF编码中，它还给工作线程和UI线程提供了交互的能力。

实际上， `Thread` 和 `ThreadPool` 默认都没有提供这种交互能力，而 `BackgroundWorker` 却通过事件提供了这种能力。这种能力包括：报告进度、支持完成回调、取消任务、暂停任务等。

`BackgroundWorker` 的简单示例如下：

```csharp
private BackgroundWorker backgroundWorker = new BackgroundWorker();

private void AsyncButton_Click(object sender, RoutedEventArgs e)
{
    //注册要执行的任务
    backgroundWorker.DoWork += BackgroundWorker_DoWork;
    //注册报告进度
    backgroundWorker.ProgressChanged += BackgroundWorker_ProgressChanged;
    //注册完成时的回调
    backgroundWorker.RunWorkerCompleted += BackgroundWorker_RunWorkerCompleted;
    //设置允许任务取消
    backgroundWorker.WorkerSupportsCancellation = true;
    //设置允许报告进度
    backgroundWorker.WorkerReportsProgress = true;
    backgroundWorker.RunWorkerAsync();
}
private void Cancel_Click(object sender, RoutedEventArgs e)
{
    //取消任务
    if (backgroundWorker.IsBusy)
        backgroundWorker.CancelAsync();
}
private void BackgroundWorker_RunWorkerCompleted(object? sender, RunWorkerCompletedEventArgs e)
{
    //完成时回调
    MessageBox.Show("BackgroundWorker RunWorkerCompleted");
}

private void BackgroundWorker_ProgressChanged(object? sender, ProgressChangedEventArgs e)
{   
    //报告进度
    this.textbox.Text = e.ProgressPercentage.ToString();
}

private void BackgroundWorker_DoWork(object? sender, DoWorkEventArgs e)
{
    BackgroundWorker? worker = sender as BackgroundWorker;

    if (worker != null)
    {
        for (int i = 0; i < 20; i++)
        {
            if (worker.CancellationPending)
            {
                e.Cancel = true;
                break;
            }
            worker.ReportProgress(i);

            Thread.Sleep(100);
        }
    }
}
```

建议使用WinForm和WPF的开发人员使用 `BackgroundWorker`。

## Task替代ThreadPool

`ThreadPool` 相对于 `Thread` 来说具有很多优势，但是 `ThreadPool` 在使用上却存在一定的不方便。比如：
- `ThreadPool` 不支持线程的取消、完成、失败通知等交互性操作。
- `ThreadPool` 不支持线程执行的先后次序。

所以随着 `Task` 类及其所提供的异步编程模型的引入，`Task`相较`ThreadPool`具有更多的优势。大概有一下几点：


1. Task是.NET Framework的一部分，它提供了更高级别的抽象来表示异步操作或并发任务。相比之下，ThreadPool较为底层，需要手动管理线程池和任务队列。通过使用Task，我们可以以更简洁、更可读的方式表达并发逻辑，而无需关注底层线程管理的细节。


2. Task是基于Task Parallel Library（TPL）构建的核心组件，它提供了强大的异步编程支持。利用Task，我们能够轻松定义异步方法、等待异步操作完成以及处理任务结果。与此相反，ThreadPool主要用于执行委托或操作，缺乏直接的异步编程功能。
 
3. Task在底层使用ThreadPool来执行任务，但它提供了更优秀的性能和资源管理机制。通过使用Task，我们可以利用TPL提供的任务调度器，智能化地管理线程池的大小、工作窃取算法和任务优先级。这样一来，我们能够更有效地利用系统资源，并获得更好的性能表现。

 
4. Task拥有强大的任务关联和组合功能。我们可以使用Task的 `ContinueWith()` 、 `When()` 、`WhenAll()` 、`Wait()`等方法定义任务之间的依赖关系，以及在不同任务完成后执行的操作。这种任务组合方式使并发编程更加灵活且易于管理。


5. Task提供了更好的异常处理和取消支持机制。我们可以利用Task的异常处理机制捕获和处理任务中的异常，而不会导致整个应用程序崩溃。此外，Task还引入 `CancellationToken` 的概念，可用于取消任务的执行，从而更好地控制并发操作。

 
所以，尽管ThreadPool在某些情况下仍然有其用途，但在C#编程中，使用Task替代ThreadPool已变为通用实践，推荐优先考虑使用Task来处理并发任务。

>以上部分内容引用自
>
>编写高质量代码：改善C#程序的157个建议 / 陆敏技著.一北京：机械工业出版社，2011.9