• Nginx
• Redis

Redis

1. 安装服务

在 redis 目录下以管理员身份执行

1

redis-server --service-install redis.windows.conf

2. 启动 Redis 服务

1
2
3
4
5

redis-server --service-start

或任意位置

net start nginx

3. 停止服务（如需）

1
2
3
4
5

redis-server --service-stop

或任意位置

net stop nginx

Nginx

Nginx 使用 WinSW 进行托管

1. 下载对应版本（x86/x64）的 WinSW https://github.com/winsw/winsw/releases
2. 将下载的 WinSW-X86(X64).exe 重命名为 nginx-service.exe 并和 nginx.exe 放一起
3. 新建文件 nginx-service.xml，并和 nginx-service.exe 放一起，内容如下

1
2
3
4
5
6
7
8

<service>
  <id>nginx</id>
  <name>Nginx</name>
  <description>Nginx Service</description>
  <executable>nginx.exe</executable>
  <stopexecutable>nginx.exe -s stop</stopexecutable>
  <logpath>logs/</logpath>
</service>

4. 在 nginx 目录下以管理员身份执行

1
2
3

nginx-service.exe install

net start nginx

但在 windows 下文档并没有说如何实现，这里说下本人在 windows 下的使用方法和经验。

以下有两种实现方式，都亲测稳定使用。

方法 1：任务计划管理程序

在 计算机管理 -> 系统工具 -> 任务计划程序 -> 任务计划程序库 中添加一个任务

• 常规 选项卡
  • 填写名称，任意即可，如 YourApi
  • 勾选 不管用户是否...
  • 勾选 不存储密码...
  • 勾选 使用最高权限...
  • 勾选 隐藏
• 触发器 选项卡，添加触发器，设为 在系统启动时
• 操作 选项卡，新建操作，设置程序的路径和启动参数，如
  • 程序或脚本 设置为 E:\YourApi\YourApi.exe
• 条件 选择卡，取消勾选 只有在计算机使用交流电源...
• 设置 选项卡
  • 勾选 允许按需允许任务
  • 勾选 如果任务失败，按以下频率重新启动，按需设置间隔和次数
  • 取消勾选 如果任务允许时间超过...
  • 取消勾选 如果请求后任务还在运行...

保存后，右键单击新建的条目，再点 运行 即可。

后续电脑重启都会自动运行，或者在任务计划程序这里通过点击右键菜单运行和结束来控制运行。

实测中文路径可能会影响自动启动，建议使用无特殊字符的英文路径。

方法 2：使用系统自带 sc.exe

这种方式可以将程序作为服务运行，需要修改代码才能支持

在 Program.cs 中添加代码

1

builder.Host.UseWindowsService();

如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

using Microsoft.Extensions.Hosting.WindowsServices;

var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
    Args = args,
    ContentRootPath = WindowsServiceHelpers.IsWindowsService()
        ? AppContext.BaseDirectory
        : default
});

// 添加 Windows 服务支持
builder.Host.UseWindowsService();

var app = builder.Build();
app.Run();

编译后在目标计算机的控制台执行

1

sc create <name> binPath="<.exe 路径>" start=auto

<name> 是自定义服务名， .exe 路径 是编译后的可执行程序的绝对路径

如

1

sc create YourService binPath="D:\YourApi\YourApi.exe" start=auto

此时如果打开 服务 就能看到刚才新增的服务了。

打开 服务 窗口方式：win+R 运行输入 services.msc

设置故障重启

上面脚本已经开启了自动启动，因此这里只用设置故障重启即可。

可以使用 服务 窗口图形化设置，右键单击服务后点击 属性，在 恢复 选项卡中设置失败策略

也可以用脚本设置，如

1

sc failure "服务名" actions= restart/60000 reset= 86400

这表示服务失败后会自动重启（延迟 60 秒），如果 24 小时(86400 秒)内没有再次失败，则失败计数重置。

但在 windows 下文档并没有说如何实现，这里说下本人在 windows 下的使用方法和经验。

以下有两种实现方式，都亲测稳定使用。

方法 1：任务计划管理程序

在 计算机管理 -> 系统工具 -> 任务计划程序 -> 任务计划程序库 中添加一个任务

• 常规 选项卡
  • 填写名称，任意即可，如 frp
  • 勾选 不管用户是否...
  • 勾选 不存储密码...
  • 勾选 使用最高权限...
  • 勾选 隐藏
• 触发器 选项卡，添加触发器，设为 在系统启动时
• 操作 选项卡，新建操作，设置 frp 的路径和启动参数，如
  • 程序或脚本 设置为 E:\frp\frpc.exe
  • 添加参数（可选） 设置为 -c "E:\frp\frpc.ini"
• 条件 选择卡，取消勾选 只有在计算机使用交流电源...
• 设置 选项卡
  • 勾选 允许按需允许任务
  • 勾选 如果任务失败，按以下频率重新启动，按需设置间隔和次数
  • 取消勾选 如果任务允许时间超过...
  • 取消勾选 如果请求后任务还在运行...

保存后，右键单击新建的条目，再点 运行 即可。

后续电脑重启都会自动运行，或者在任务计划程序这里通过点击右键菜单运行和结束来控制运行。

实测中文路径可能会影响自动启动，建议使用无特殊字符的英文路径。

方法 2：使用 pm2

pm2 虽然是管理 nodejs 的，但实测也可以托管 frp 程序，且运行稳定。

这个方法需要 nodejs 环境，如果没有，自行搜索安装方式。

下面直接使用

安装 npm 包

1
2

npm install -g pm2
npm install -g pm2-windows-startup

添加并启动服务

1

pm2 start -n <name> <frp.exe 路径> -- -c "<配置文件路径>"

frp 参数是服务名称，可自定义，frpc.exe 和 frpc.ini 的路径替换为你的实际路径。

如

1

pm2 start -n frp E:\frp\frpc.exe -- -c "E:\frp\frpc.ini"

设置自动启动

上面脚本默认是有故障重启的，因此这里只用设置开机自启即可。

控制台执行语句

1
2

pm2-startup install
pm2 save

其他守护程序

本人也尝试过其他守护程序，主流的如 nssm 和 WinSW 目前都已经不再维护。

ts 类型体操，是对 ts 类型计算的一种戏称，因为 ts 的类型非常灵活，且复杂度够深。

做操之前，先保证了解这些：

• JavaScript 语法
• TypeScript 语法

基础

TypeScript 的类型系统也可以做很多运算，现在我们来了解一些基础逻辑运算。

交叉 &

对类型做合并

1

type NewType = { a: number } & { b: string };

联合 |

表示可以是多种类型之一

1

type Union = "a" | "b" | 1 | 2;

约束 extends

可以为模板类限制类型

1
2
3
4
5
6
7
8

interface Base {
  length: number;
}

// T extends Base 限制了 T 必须包含 length，而且 length 的类型必须是 number
function fn1<T extends Base>(arg: T): number {
  return arg.length;
}

条件 T extends U ? X : Y

类似三元表达式，即如果 T 是 U 的子类型，那么类型是 X，否则是 Y

1
2
3
4

type IsString<T> = T extends string ? string : number;

type t1 = IsString<1>; // number
type t2 = IsString<"abc">; // string

索引查询 keyof T

获取类型的所有键的联合类型

1
2
3
4
5

const obj = {
  name: "string",
  age: 1,
};
type t2 = keyof typeof obj; // 'name' | 'age'

索引访问 T[K]

取类型中索引的类型

1
2
3
4
5
6

type TestInterface = {
  name: string;
  age: number;
};

type t = TestInterface["name"]; // string

配合 keyof 还可以获取所有索引的联合类型

1
2
3
4
5
6

type TestInterface = {
  name: string;
  age: number;
};

type t = TestInterface[keyof TestInterface]; // string | number

遍历索引 in

用于遍历联合类型，常配合 keyof 使用，可以根据已有类型创建新类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14

const obj = {
  name: "string",
  age: 1,
};

type t = {
  [P in keyof typeof obj]: string;
};

// 等同于
// type t = {
//   name: boolean;
//   age: boolean;
// };

再比如复制出一份只读类型，给所有索引都加上 readonly 修饰

1
2
3

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

或去掉 readonly

1
2
3

type NotReadonly<T> = {
  -readonly [P in keyof T]: T[P];
};

索引重映射 as

在索引后面加个 as 语句，可以对索引类型做过滤和转换

比如仅保留类型为 number 的索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

type FilterNumber<T> = {
  [P in keyof T as T[P] extends number ? P : never]: T[P];
};

type t1 = {
  name: string;
  age: number;
};

type t2 = FilterNumber<t1>;

// 等同于
// type t2 = {
//   age: number;
// };

再比如给索引都加上前缀 prefix-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type AddPrefix<T> = {
  [P in keyof T as `prefix-${P & string}`]: T[P];
};

type t1 = {
  name: string;
  age: number;
};

type t2 = AddPrefix<t1>;

// 等同于
// type t2 = {
//   "prefix-name": string;
//   "prefix-age": number;
// }

再如，交换类型的 key 和 value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type Flip<T extends Record<any, any>> = {
  [Key in keyof T as `${T[Key]}`]: Key;
};

type t1 = {
  name: "wang";
  age: 18;
};

type t2 = Flip<t1>;

// 等同于
// type t2 = {
//     wang: "name";
//     18: "age";
// }

TypeScript 内置高级类型

内置高级类型是利用基础语法，做出各种变换，从而支持高级类型。类型体操也是同样的过程和操作

Readonly

把索引改为只读，用 in 操作符遍历索引，映射为一个新类型，并将索引改为 readonly

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

type t1 = {
  name: "string";
  age: 18;
};

type t2 = Readonly<t1>;

// 等同于
// type t2 = {
//   readonly name: 'string';
//   readonly age: 18;
// }

Partial

把索引变为可选，用 in 操作符遍历索引，映射为一个新类型，给索引加上 ?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type Partial<T> = {
  [P in keyof T]?: T[P];
};

type t1 = {
  name: "string";
  age: 18;
};

type t2 = Partial<t1>;

// 等同于
// type t2 = {
//   name?: "string" | undefined;
//   age?: 18 | undefined;
// }

Required

把索引变为必选，用 in 操作符遍历索引，映射为一个新类型，给索引移除 `?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type Required<T> = {
  [P in keyof T]-?: T[P];
};

type t1 = {
  name: "string";
  age?: 18;
};

type t2 = Required<t1>;

// 等同于
// type t2 = {
//   name: 'string';
//   age: 18;
// }

Pick

用 in 遍历自定义参数，配合联合类型，生成新的映射类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};

type t1 = {
  name: "string";
  age: 18;
  email: "string";
};

type t2 = Pick<t1, "name" | "age">;

// 等同于
// type t2 = {
//   name: "string";
//   age: 18;
// }

Record

用 in 遍历自定义参数，创建新的映射类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

type Record<K extends keyof any, T> = {
  [P in K]: T;
};

type t1 = {
  name: "string";
  age: 18;
  email: "string";
};

type t2 = Record<"name" | "age", boolean>;

// 等同于
// type t2 = {
//   name: boolean;
//   age: boolean;
// }

Exclude

排除联合类型的部分类型

1
2
3
4
5
6

type Exclude<T, U> = T extends U ? never : T;

type t1 = Exclude<"name" | "age", "name">;

// 等同于
// type t1 = "age";

Extract

取联合类型的部分类型，与 Exclude 相反

1
2
3
4
5
6

type Extract<T, U> = T extends U ? T : never;

type t1 = Extract<"name" | "age", "name">;

// 等同于
// type t1 = "name";

Omit

删除类型中的部分索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

type t1 = {
  name: "string";
  age: 18;
  email: "string";
};

type t2 = Omit<t1, "name" | "age">;

// 等同于
// type t2 = {
//   email: "string";
// }

简单体操

未完待续

• 前台线程/后台线程
• 线程优先级
• 实现多线程的方法 Thread / ThreadPool / Parallel / Task / BackgroundWorker
• 线程同步，线程锁

C# 中的多线程

在操作系统中创建进程 Process 比较耗资源，因此 CLI 引入了 AppDomain

AppDomain 并不存在于操作系统，只存在于 .NET CLI 中，并且不能脱离于 Process

一个 Process 中可以有多个 AppDomain，从而可以使用 AppDomain 隔离同一进程下的资源

多个 AppDomain 之间不能互相访问代码。在程序层面，一个 AppDomain 相当于一个独立的程序

每个 AppDomain 下可以拥有多个 Thread

在多线程程序开发中，一般使用的都是 Thread 或其封装类

前台/后台线程

线程按功能分为两类

• 前台线程
• 后台线程

前台线程

前台线程一般用来处理输入输出、响应事件、处理消息

UI 线程属于前台线程

如果前台线程都已经结束，那么这个程序就不再运行。反之只要有前台线程在运行，程序就在运行

如果程序退出后，因为异常而没有退出干净，在任务管理器中仍然能看到，就是因为存在没有结束的前台线程

后台线程

后台线程一般用于处理耗时的任务，不会造成界面卡顿

程序退出时，所有后台线程会被强制关闭。因此退出程序可以不用手动停止后台线程。

优先级

在多线程并发环境中，多线程的执行顺序是随机不可预测的

线程开始后，只是被放在线程池中等待 CPU 调度

优先级越高的线程， CPU 分配给该线程的时间片就更多

因此优先级高并不代表肯定先执行，只是先执行的机会更大，先执行结束的可能性也更大

实现多线程的方法

实现多线程最基础的方法是用 Thread，除此之外还有几种抽象出来的类也可以实现多线程

• Thread 线程
• ThreadPool 线程池
• Parallel
• Task
• BackgroundWorker

Thread

使用多线程最基础的类

1
2
3
4

var thread = new Thread(()=>{
  // DO
});
thread.Start();

传参

Start 函数也可以传参

1
2
3
4

var thread = new Thread((obj)=>{
  // DO
});
thread.Start("Thread");

线程命名

Thread 有 Name 属性，赋值后有利于代码调试

Name 只能赋值一次

前台/后台线程

Thread 类默认创建为前台线程，可通过 IsBackground 属性，设置或获取该线程属于前台线程还是后台线程

ThreadPool

ThreadPool（线程池）维护了多个线程，用于执行小任务，防止频繁创建线程

在线程池中的线程执行完后不会自动移除，而是处于挂起的状态，如果再次向线程池发出请求，那么挂起的线程会被激活，不用创建新的线程就可以执行任务，可以节约创建和销毁线程的开销

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System.Diagnostics;

const int count = 1000;

{
    var watch = new Stopwatch();
    watch.Start();

    for (int i = 0; i < count; i++)
    {
        new Thread(() => { }).Start();
    }

    watch.Stop();
    Console.WriteLine($"Thread 创建 {count} 个线程需要花费时间 (Ticks)：{watch.ElapsedTicks}");
}

{
    var watch = new Stopwatch();
    watch.Start();

    for (int i = 0; i < count; i++)
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => { }));
    }

    watch.Stop();
    Console.WriteLine($"ThreadPool 创建 {count} 个线程需要花费时间 (Ticks)：{watch.ElapsedTicks}");
}


Console.ReadKey();

输出

1
2

Thread 创建 1000 个线程需要花费时间 (Ticks)：744179
ThreadPool 创建 1000 个线程需要花费时间 (Ticks)：814

可以看出 ThreadPool 创建线程消耗的时间是非常小的

加入任务

1
2
3

public static bool QueueUserWorkItem(WaitCallback callBack);
public static bool QueueUserWorkItem(WaitCallback callBack, object? state);
public static bool QueueUserWorkItem<TState>(Action<TState> callBack, TState state, bool preferLocal);

线程池的限制

• 线程池中的线程均为后台线程
• 不能设置优先级和名称
• 更适合执行时间短的任务，不应该阻塞线程池中的线程
• 最大允许 2048 个工作线程

线程数量

线程池有最大线程数量和最小线程数量

最大线程数量

如果线程的数量超出最大数量，会移除之前的线程

1

public static bool SetMaxThreads(int workerThreads, int completionPortThreads);

• workerThreads 线程池中辅助线程的最大数目
• completionPortThreads 线程池中异步 I/O 线程的最大数目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

static void WriteCount()
{
    ThreadPool.GetMaxThreads(out var workerThreads, out var completionPortThreads);
    Console.WriteLine($"线程池中辅助线程的最大数为：{workerThreads}；线程池中异步I/O线程的最大数为：{completionPortThreads}");
}

Console.Write("设置前，");
WriteCount();
if (ThreadPool.SetMaxThreads(30000, 500))
{
    ThreadPool.QueueUserWorkItem(new WaitCallback((obj) =>
    {
        Console.WriteLine("执行线程池");
    }));

    Console.Write("设置后，");
    WriteCount();
}
else
{
    Console.WriteLine("没有设置");
}

Console.ReadLine();

最小线程数量

线程池维持的最小的可用线程数，便于队列任务可以立即启动

1

public static bool SetMinThreads(int workerThreads, int completionPortThreads);

• workerThreads 当前由线程池维护的空闲辅助线程的最小数目
• completionPortThreads 当前由线程池维护的空闲异步 I/O 线程的最小数目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

static void WriteCount()
{
    ThreadPool.GetMinThreads(out var minWorker, out var minCompletionPort);
    Console.WriteLine($"线程池维护的空闲辅助线程的最小数目为：{minWorker}；线程池维护的空闲异步 I/O 线程的最小数目为：{minCompletionPort}");
}

Console.Write("设置前，");
WriteCount();
if (ThreadPool.SetMinThreads(10, 2))
{
    Console.Write("设置后，");
    WriteCount();
}
else
{
    Console.WriteLine("没有设置");
}

Console.ReadLine();

Parallel

Parallel 类位于 System.Threading.Task 命名空间中，命名空间与 Task 相同

Parallel 是对 Thread 和 ThreadPool 的封装和抽象

Parallel 提供下面几个函数

• For
• ForAsync
• ForEach
• ForEachAsync
• Invoke

Parallel.For

类似于 for 循环，可以并行迭代

以最简单的重载函数为例

1

public static ParallelLoopResult For(int fromInclusive, int toExclusive, Action<int> body);

前两个参数定义了循环的开始和结束

第三个参数是任务函数体，函数的参数是循环迭代的次数

还有一些重载版本，在重载版本中支持中断和线程初始化，后面会有介绍

Parallel.ForEach

用异步的方式遍历 IEnumerable 集合，不确定遍历顺序

以最简单的重载函数为例

1

public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource> body);

第一个参数是 IEnumerable<T> 列表，第二个参数是一个 Action 委托，每个元素会执行一次委托

1
2
3
4
5
6

string[] data = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"];
Parallel.ForEach(data, (s) =>
{
    Console.WriteLine(s);
});
Console.ReadKey();

还有一些重载版本，在重载版本中支持中断和线程初始化，后面会有介绍

Parallel.Invoke

支持执行不同的方法，类似 Task.WhenAll

1

public static void Invoke(params Action[] actions);

1
2
3
4
5
6
7
8
9
10
11
12

static void Foo()
{
    Console.WriteLine("Foo");
}

static void Bar()
{
    Console.WriteLine("Bar");
}

Parallel.Invoke(Foo, Bar);
Console.ReadKey();

参数是一个 Action 委托数组

异步版本

• ForAsync
• ForEachAsync

用法类似，只是返回 Task，可以等待执行结束

中断执行

回调函数的重载版本，有的支持参数 ParallelLoopState

该对象有函数 Break() 和 Stop，可以中断任务的执行

1

public static ParallelLoopResult For(int fromInclusive, int toExclusive, Action<int, ParallelLoopState> body);

1
2
3
4
5
6
7
8
9
10
11

var result = Parallel.For(0, 100, (i, state) =>
{
    Console.WriteLine($"i:{i}, thread id: {Thread.CurrentThread.ManagedThreadId}");
    if (i > 5) state.Break();
    Thread.Sleep(10);
});

Console.WriteLine($"IsCompleted: {result.IsCompleted}");
Console.WriteLine($"LowestBreakIteration: {result.LowestBreakIteration}");

Console.ReadKey();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

i:24, thread id: 12
i:0, thread id: 1
i:54, thread id: 17
i:60, thread id: 18
i:48, thread id: 16
i:18, thread id: 11
i:30, thread id: 13
i:72, thread id: 20
i:42, thread id: 15
i:36, thread id: 14
i:6, thread id: 5
i:12, thread id: 8
i:66, thread id: 19
i:78, thread id: 21
i:84, thread id: 22
i:96, thread id: 24
i:90, thread id: 23
i:3, thread id: 11
i:1, thread id: 1
i:4, thread id: 11
i:2, thread id: 1
i:5, thread id: 11
IsCompleted: False
LowestBreakIteration: 6

线程初始化

Parallel 下的模板函数重载版本，可以对每个线程进行初始化，如

1
2

public static ParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, Func<TLocal> localInit, Func<int, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally);
public static ParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source, Func<TLocal> localInit, Func<TSource, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)

• localInit localInit 参数是一个 Func 委托，该委托会返回一个模板类型的值，回调的函数体可以通过参数获取到这个值。每个线程都会执行一次 localInit 委托，因此 localInit 可能会执行多次，也可能是 1 次

• localFinally localFinally 参数是一个 Action 委托，该委托会在每个线程完成后执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Parallel.For(
    0,
    10,
    () =>
    {
        Console.WriteLine($"init thread {Environment.CurrentManagedThreadId},\t task {Task.CurrentId}");
        return $"t{Environment.CurrentManagedThreadId}";
    },
    (i, pls, str) =>
    {
        Console.WriteLine("body i {0} \t str {1} \t thread {2} \t task {3}", i, str, Environment.CurrentManagedThreadId, Task.CurrentId);
        Thread.Sleep(10);
        return $"i \t{i}";
    },
    (str) =>
    {
        Console.WriteLine($"finally\t {str}");
    });

Console.ReadKey();

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

init thread 17,  task 15
init thread 16,  task 14
init thread 8,   task 8
init thread 15,  task 13
init thread 13,  task 11
init thread 1,   task 6
init thread 5,   task 7
body i 1         str t5          thread 5        task 7
init thread 14,  task 12
body i 6         str t14         thread 14       task 12
body i 9         str t17         thread 17       task 15
body i 8         str t16         thread 16       task 14
init thread 12,  task 10
body i 4         str t12         thread 12       task 10
body i 7         str t15         thread 15       task 13
body i 5         str t13         thread 13       task 11
body i 0         str t1          thread 1        task 6
init thread 11,  task 9
body i 3         str t11         thread 11       task 9
body i 2         str t8          thread 8        task 8
finally  i      5
finally  i      6
finally  i      0
finally  i      4
finally  i      7
finally  i      3
finally  i      8
finally  i      9
finally  i      2
finally  i      1

Task

Task 提供的多线程更加灵活

• 支持并行任务
• 支持连续任务，即上一个任务结束后再决定是否执行下一个任务
• 支持任务嵌套，一个任务中可以再开启多个任务
• 可以获取任务的返回值
• 任务基于线程，最终执行是需要线程来执行的
• 任务和线程不是一对一关系，一个线程可能有多个任务
• 相比于线程，任务的开销更小，控制更精确

启动任务

有多种方式启动一个任务

1
2
3
4
5

_ = Task.Run(() =>
{
    Console.WriteLine("Foo");
});
Console.ReadKey();

1
2
3
4
5
6

var task = new Task(() =>
{
    Console.WriteLine("Foo");
});
task.Start();
Console.ReadKey();

1
2
3
4
5
6

var tf = new TaskFactory();
var task = tf.StartNew(() =>
{
    Console.WriteLine("Foo");
});
Console.ReadKey();

1
2
3
4
5

_ = Task.Factory.StartNew(() =>
{
    Console.WriteLine("Foo");
});
Console.ReadKey();

上述方法也都支持给任务传参

任务的层次

在任务的内部，也可以创建多个子任务

父任务被取消时，子任务也会被取消

如果在任务内想创建父级任务，在创建任务时，为 TaskCreationOptions 赋值为 TaskCreationOptions.DenyChildAttach

1
2
3
4
5
6

var task = new Task(() =>
{
    Console.WriteLine("Foo");
}, TaskCreationOptions.DenyChildAttach);
task.Start();
Console.ReadKey();

长任务

默认 Task 更适合短时间运行的任务，如果要创建长时间运行的任务，应该使用 TaskCreationOptions.LongRunning

这样就不再使用线程池中的线程，会告诉任务管理器创建一个新的线程

1
2
3
4
5
6

var task = new Task(() =>
{
    Console.WriteLine("Foo");
}, TaskCreationOptions.LongRunning);
task.Start();
Console.ReadKey();

任务控制

task.Wait

调用函数 Task.Wait 可以等待任务执行完毕，即 Task 的状态变为 Completed

1
2
3
4
5
6

public void Wait();
public void Wait(CancellationToken cancellationToken);
public bool Wait(int millisecondsTimeout);
public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
public bool Wait(TimeSpan timeout);
public bool Wait(TimeSpan timeout, CancellationToken cancellationToken);

Task.WaitAll

等待所有任务执行完毕，参数接收多个 Task 对象

1
2
3
4
5

public static void WaitAll(params Task[] tasks);
public static bool WaitAll(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken);
public static void WaitAll(Task[] tasks, CancellationToken cancellationToken);
public static bool WaitAll(Task[] tasks, TimeSpan timeout);
public static bool WaitAll(Task[] tasks, int millisecondsTimeout);

Task.WatiAny

类似 Task.WaitAll，但只需要任一任务完成，就不再等待

task.ContinueWith

任务完成后自动执行下一个 Task，实现链式执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Task task1 = Task.Run(() =>
{
    Console.WriteLine("Current Task id = {0}", Task.CurrentId);
    Console.WriteLine("执行任务1\r\n");
    Thread.Sleep(10);
});

Task task2 = task1.ContinueWith((t) =>
{
    Console.WriteLine("Last Task id = {0}", t.Id);
    Console.WriteLine("Current Task id = {0}", Task.CurrentId);
    Console.WriteLine("执行任务2\r\n");
    Thread.Sleep(10);
});

Task task3 = task2.ContinueWith((t) =>
{
    Console.WriteLine("Last Task id = {0}", t.Id);
    Console.WriteLine("Current Task id = {0}", Task.CurrentId);
    Console.WriteLine("执行任务3\r\n");
}, TaskContinuationOptions.OnlyOnRanToCompletion);

Console.ReadKey();

输出

1
2
3
4
5
6
7
8
9
10

Current Task id = 9
执行任务1

Last Task id = 9
Current Task id = 10
执行任务2

Last Task id = 10
Current Task id = 11
执行任务3

task.RunSynchronously

在当前线程上执行任务

如果当前线程是 UI 线程，这个操作会造成界面卡顿

任务取消

启动任务时传入 Token，在任务中的各个适当位置判断 Tokan 状态并退出任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var task = Task.Run(() =>
{
    for (var i = 0; i < 1000; i++)
    {
        Console.WriteLine(i);
        System.Threading.Thread.Sleep(1000);
        if (token.IsCancellationRequested)
        {
            Console.WriteLine("Abort mission success!");
            return;
        }
    }
}, token);
token.Register(() =>
{
    Console.WriteLine("Canceled");
});
Console.WriteLine("Press enter to cancel task...");
Console.ReadKey();
tokenSource.Cancel();
Console.ReadKey();

输出

1
2
3
4
5
6
7
8
9

Press enter to cancel task...
0
1
2
3
4
5
Canceled
Abort mission success!

BackgroundWorker

BackgroundWorker 实现多线程运算更安全、更简单

• 提供几种事件，可以在任务的各个阶段触发
• 提供了 CancleAsync 方法，方便取消任务
• 能后台异步操作的同时，也能通知 UI 线程进度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

using System.ComponentModel;

var worker = new BackgroundWorker()
{
    WorkerSupportsCancellation = true,
    WorkerReportsProgress = true,
};
worker.DoWork += Worker_DoWork;
worker.ProgressChanged += Worker_ProgressChanged;
worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
worker.RunWorkerAsync();

void Worker_RunWorkerCompleted(object? sender, RunWorkerCompletedEventArgs e)
{
    Console.WriteLine($"RunWorkerCompleted, Cancelled: {e.Cancelled}");
}

void Worker_ProgressChanged(object? sender, ProgressChangedEventArgs e)
{
    Console.WriteLine($"ProgressChanged, ProgressPercentage:{e.ProgressPercentage}");
}

void Worker_DoWork(object? sender, DoWorkEventArgs e)
{
    var times = 1;
    while (!worker.CancellationPending)
    {
        if (times >= 6)
        {
            worker.CancelAsync();
        }

        worker.ReportProgress(times);
        Console.WriteLine($"DoWork {times++}");
        Thread.Sleep(100);
    }
}

Console.ReadKey();

输出

1
2
3
4
5
6
7
8
9
10
11
12
13

DoWork 1
ProgressChanged, ProgressPercentage:1
DoWork 2
ProgressChanged, ProgressPercentage:2
DoWork 3
ProgressChanged, ProgressPercentage:3
DoWork 4
ProgressChanged, ProgressPercentage:4
DoWork 5
ProgressChanged, ProgressPercentage:5
DoWork 6
ProgressChanged, ProgressPercentage:6
RunWorkerCompleted, Cancelled: False

线程同步

多个线程的执行顺序是不可预测的，但有时候需要多个线程访问共享的数据和资源，这个时候就需要使用一些方法来达到线程同步

线程锁

• Mutex 互斥锁
• SpinLock 自旋锁
• Monitor
• lock

Mutex

互斥锁，可以用于共享资源每次只能被一个线程访问的情况

Mutex 消耗的资源较大，不适合频繁操作

Mutex 可以跨进程，是系统级的。比如可以用 Mutex 实现一个程序不能多次打开

如果锁已被其他线程获取，第二次获取的线程将挂起，直到第一个线程释放互斥锁

• WaitOne() 阻止线程，直至收到信号，参数可以指定超时时间
• ReleaseMutex() 释放一次锁（其他线程即获取锁）
• OpenExisting() 获取指定命名的互斥锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

var mutex = new Mutex();
bool executed = false;
void Execute(int num)
{
    if (mutex.WaitOne())
    {
        try
        {
            if (!executed)
            {
                Console.WriteLine($"{num}：已执行");
                executed = true;
            }
            else
            {
                Console.WriteLine($"{num}：跳过执行");
            }
        }
        finally
        {
            mutex.ReleaseMutex();
        }
    }
}

for (int i = 1; i < 10; i++)
{
    _ = Task.Factory.StartNew(obj => { Execute((int)obj!); }, i);
}
Console.ReadLine();

输出

1
2
3
4
5
6
7
8
9

2：已执行
3：跳过执行
4：跳过执行
1：跳过执行
5：跳过执行
7：跳过执行
8：跳过执行
9：跳过执行
6：跳过执行

SpinLock

当一个线程获取锁对象时，如果锁已经被其他线程获取，那么这个线程就会循环等待（自旋），并且不断的获取锁，直至获取到锁

因此自旋锁不会让线程处于等待状态，有助于避免阻塞

一般用于短时间锁定的场景，如果有大量阻塞，旋转过多会影响性能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

var spinLock = new SpinLock();
bool executed = false;
void Execute(int num)
{
    bool lockTaken = false;
    try
    {
        spinLock.Enter(ref lockTaken);

        if (!executed)
        {
            Console.WriteLine($"{num}：已执行");
            executed = true;
        }
        else
        {
            Console.WriteLine($"{num}：跳过执行");
        }
    }
    finally
    {
        if (lockTaken)
        {
            spinLock.Exit();
        }
    }
}

for (int i = 1; i < 10; i++)
{
    _ = Task.Factory.StartNew(obj => { Execute((int)obj!); }, i);
}
Console.ReadLine();

输出

1
2
3
4
5
6
7
8
9

2：已执行
3：跳过执行
1：跳过执行
4：跳过执行
7：跳过执行
5：跳过执行
6：跳过执行
8：跳过执行
9：跳过执行

Monitor

Monitor 是一种轻量级的互斥锁，能确保同一时刻只有一个线程执行代码块

Monitor.Enter 方法锁定对象
Monitor.Exit 方法释放对象
Monitor.TryEnter 可以指定获取对象锁的最长时间，能避免出现死锁

1
2
3
4
5
6
7
8
9
10

var obj = new object();
Monitor.Enter(obj);
try
{
    // TODO
}
finally
{
    Monitor.Exit(obj);
}

lock

lock 的本质就是 Monitor 实现的，因此在 lock 块中可以使用 Monitor 的所有方法

1
2
3
4

var obj = new object();
lock(obj){
  // TODO
}

等同于

1
2
3
4
5
6
7
8
9
10

var obj = new object();
Monitor.Enter(obj);
try
{
    // TODO
}
finally
{
    Monitor.Exit(obj);
}

事件

有两种可以实现线程同步的事件

• AutoResetEvent
• ManualResetEvent

可以控制是否阻塞线程

• WaitOne() 阻塞当前线程，直到收到释放信号，可以传参指定超时时长，避免死锁
• Set() 释放阻塞
• Reset() 将状态改为非终止状态，即阻塞所有的 WaitOne

AutoResetEvent

AutoResetEvent 收到 Set 只会有一个线程的 WaitOne 被处理，其他线程继续等待

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

var resetEvent = new AutoResetEvent(false);

void Execute(int num)
{
    Console.WriteLine($"{num} 等待");
    resetEvent.WaitOne();

    Console.WriteLine($"{num} 执行");

    Thread.Sleep(1000);
    Console.WriteLine($"{num} 结束");
    resetEvent.Set();
}

for (int i = 1; i < 5; i++)
{
    _ = Task.Factory.StartNew(obj => { Execute((int)obj!); }, i);
    Thread.Sleep(50);
}

resetEvent.Set();
Thread.Sleep(7000);
resetEvent.WaitOne();
_ = Task.Factory.StartNew(obj => { Execute((int)obj!); }, 10);

Thread.Sleep(1000);
resetEvent.Set();
resetEvent.WaitOne();
Console.WriteLine($"结束");

Console.ReadLine();

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1 等待
2 等待
3 等待
4 等待
2 执行
2 结束
4 执行
4 结束
3 执行
3 结束
1 执行
1 结束
10 等待
10 执行
10 结束
结束

ManualResetEvent

ManualResetEvent 收到 Set 会处理所有线程的 WaitOne，而且新进入的 WaitOne 也不再等待

除非调用了 Reset 重置信号，才会将 Set 产生的影响消除

如果将前面示例代码的 AutoResetEvent 类换成 ManualResetEvent

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1 等待
2 等待
3 等待
4 等待
4 执行
3 执行
2 执行
1 执行
3 结束
2 结束
1 结束
4 结束
10 等待
10 执行
10 结束
结束

信号量

• Semaphore 可以是系统范围信号量，也可以是本地信号量，限制可同时访问某一资源或资源池的线程数
• SemaphoreSlim 更轻量、速度更快，用于单个进程内的等待，是 Semaphore 的轻量替代

构造函数的参数 initialCount 表示同时允许多少个 Wait() 不等待

• Release() 退出信号量
• WaitOne() 阻塞线程，直到收到信号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

var semaphore = new SemaphoreSlim(3);

void Execute(int num)
{
    Console.WriteLine($"{num}等待");
    semaphore.Wait();
    Console.WriteLine($"{num}执行");
    Thread.Sleep(100);
    Console.WriteLine($"{num}结束");
    semaphore.Release();
}

for (int i = 1; i < 6; i++)
{
    _ = Task.Factory.StartNew(obj => { Execute((int)obj!); }, i);
}

Console.ReadLine();

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4等待
1等待
3等待
2等待
5等待
4执行
2执行
5执行
5结束
4结束
2结束
1执行
3执行
1结束
3结束

定时器

在 C# 中有多种定时器，常见通用的两种为

• System.Threading.Timer 线程计时器
• System.Timers.Timer 服务器计时器

还有和框架相关的，如

框架相关的定时器

都是单线程的，并且在 UI 线程中执行，因此可以操作 UI 控件

一般仅做一些简单的和 UI 交互的定时操作，耗时操作会导致 UI 卡顿

System.Threading.Timer

线程计时器是轻量计时器，基于线程池实现，工作在后台线程

如果前一个执行还未结束，会新开个线程执行新任务

不是线程安全的

1
2
3
4
5
6

new System.Threading.Timer((obj) =>
{
    Console.WriteLine($"当前线程：{Environment.CurrentManagedThreadId}");
    Thread.Sleep(20);
}, null, 10, 10);
Console.ReadLine();

输出

1
2
3
4
5
6
7
8
9
10

当前线程：11
当前线程：5
当前线程：10
当前线程：11
当前线程：10
当前线程：5
当前线程：10
当前线程：5
当前线程：10
...

System.Timers.Timer

服务器计时器是针对服务器的服务程序，不过一般程序都可以使用

对多线程环境下有更多优化

如果前一个执行还未结束，与 System.Threading.Timer 相同，会新开个线程执行新任务

1
2
3
4
5
6
7
8
9
10

var timer = new System.Timers.Timer(10);
timer.Elapsed += Timer_Elapsed;
timer.Start();
Console.ReadLine();

static void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
{
    Console.WriteLine($"当前线程：{Environment.CurrentManagedThreadId}");
    Thread.Sleep(20);
}

输出

1
2
3
4
5
6
7
8
9
10

当前线程：5
当前线程：11
当前线程：10
当前线程：11
当前线程：5
当前线程：11
当前线程：5
当前线程：11
当前线程：5
...

AutoReset

AutoReset 属性默认为 false，如果设为 true，那么执行一次 Elapsed 后就不再执行了

SynchronizingObject

SynchronizingObject 属性可以指定同步上下文

比如指定为 UI 控件，则回调会在 UI 线程中执行

本文使用一个更强大的 UnoCSS，目前 Blazor 集成 UnoCSS 的教程却一个也找不到

这里记录一下如何在 Blazor 中集成 UnoCSS，相信能给你带来更愉快的开发体验

本文对应源码：https://github.com/hal-wang/BlazorUnoCSS

本文均使用 pnpm，你也可以对应替换为 npm 或 yarn 等

UnoCSS 更强大好用

在 Blazor 中，网上的教程都是使用 postcss 集成 tailwindcss

但 postcss 对 tailwindcss 支持度在 Blazor 中其实不太好

举个例子，比如 pt-30、pt-30.2，在 tailwindcss 中不可以使用，因为没有预设这个

但是根据本教程在集成 UnoCSS 后的 Blazor 却可以

因此按本教程集成 UnoCSS 后，不需要看着文档开发，自由度也更高

下面我们开始在 Blazor 集成 UnoCSS

安装 js 依赖

在项目下执行语句，以创建 package.json 文件

1

npm init -y

在 package.json 文件中，增加 postcss 生成语句，用于生成 css

1
2
3

"scripts": {
  "buildcss": "postcss wwwroot/app.css -o wwwroot/app.min.css"
},

安装依赖

1
2
3

pnpm add @unocss/postcss
pnpm add postcss-cli
pnpm add unocss

此时 package.json 应该类似下面这样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

{
  "name": "blazor-unocss",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "buildcss": "postcss wwwroot/app.css -o wwwroot/app.min.css"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@unocss/postcss": "^0.59.4",
    "postcss-cli": "^11.0.0",
    "unocss": "^0.59.4"
  }
}

配置 unocss 和 postcss

增加文件 postcss.config.mjs

1
2
3
4
5
6

// postcss.config.mjs
import unocss from "@unocss/postcss";

export default {
  plugins: [unocss()],
};

增加文件 uno.config.mjs

1
2
3
4
5
6
7
8
9

// uno.config.mjs
import { defineConfig, presetUno } from "unocss";

export default defineConfig({
  content: {
    filesystem: ["**/*.{html,js,ts,jsx,tsx,razor,cshtml}"],
  },
  presets: [presetUno()],
});

增加或修改文件 wwwroot/app.css

1
2

/* wwwroot/app.css */
@unocss;

现在如果执行语句 npm run buildcss，会在 wwwroot/app.min.css生成计算后的 css 文件

因此我们需要引用这个生成的文件

引用 css 文件

修改 App.razor 文件（有可能是其他文件，包含 html 头部基元信息）

增加

1

<link rel="stylesheet" href="app.min.css" />

配置编译脚本

修改 Blazor 项目 .csproj 文件，增加 PreBuild

1
2
3

<Target Name="PreBuild" BeforeTargets="PreBuildEvent">
<Exec Command="npm run buildcss" />
</Target>

之后每次编译项目，都会自动执行语句 npm run buildcss

不需要再手动执行

源码

GitHub: https://github.com/hal-wang/BlazorUnoCSS

他们表示连续的内存块，没有任何复制语义，类似于指针。

另外还有只读版本 ReadOnlySpan<T> 和 ReadOnlyMemory<T>

类型

C# 允许以不安全的方式使用指针，类似 C/C++。虽然效率高，但指针不被 GC 跟踪，容易造成内存泄漏

为此在 C# 7 中引入了新的类型

• Span<T> 以类型安全的方式表示内存的连续部分
• Memory<T> 连续的内存区域
• ReadOnlySpan<T> 与 Span<T> 类似，但内存区域是只读的
• ReadOnlyMemory<T> 与 ReadOnlyMemory<T> 类似，但内存连续区域是只读的

C# 7 对应的 .net 版本是 .NET Core 2.1。在后续更新中逐渐增强完善

截至目前 C# 版本是 C# 12，因此本文内容也是以 C# 12 为基础

Span<T> 的原理

Span<T> 是值类型的 ref struct，定义类似于

1
2
3
4
5
6

public readonly ref struct Span<T>
{
  private readonly ref T _pointer;
  private readonly int _length;
  ...
}

ref struct

ref struct 和 struct 相比有一些使用限制

• 不能是数组的元素类型
• 不能是类或非 ref struct 的字段的声明类型
• 不能实现接口
• 不能被装箱为 System.ValueType 或 System.Object
• 不能是类型参数
• 变量不能由 Lambda 表达式或本地函数捕获
• 变量不能在 async 方法中使用。 但是，可以在同步方法中使用 ref struct 变量，例如，在返回 Task 或 Task<TResult> 的方法中。
• 变量不能在迭代器中使用

索引器

Span<T> 的索引器是使用 ref T 声明的，因此索引器返回的是实际存储位置的引用

1
2
3
4
5
6
7

public ref T this[int index]
{
    get
    {
        //
    }
}

Memory<T>

Memory<T> 表示内存中一段连续的区域，对应的只读版本为 ReadOnlyMemory<T>。

Memory<T>很多用法与 Span<T> 相似

Memory<T> 实现原理类似如下

1
2
3
4
5
6
7

public readonly struct Memory<T>
{
  private readonly object _object;
  private readonly int _index;
  private readonly int _length;
  // ...
}

与 Span<T> 的区别

Memory<T> 的很多操作与 Span<T> 类似，可以通过数组创建 Memory<T> 并进行切片。

Memory<T> 不是 ref struct 类型，因此 Memory<T> 可以在存储在堆，所以有不同于 Span<T> 的特性

• 可以作为类的字段或属性
• 可以在异步函数中使用

Memory<T> 有个 Span 属性，可以获取 Span<T> 并处理

为什么需要 Memory<T>

有了 Span<T> 为什么还要 Memory<T>？

由于 Span<T> 无论何种情况，只能存在于栈中，因此 Span<T> 的使用限制比较多。

尤其是 Span<T> 无法在异步函数中使用，因此限制较少的 Memory<T> 更适用于这种场景。

1
2
3
4
5
6
7

static async Task<int> ChecksumReadAsync(Memory<byte> buffer, Stream stream)
{
  int bytesRead = await stream.ReadAsync(buffer);
  return Checksum(buffer.Span.Slice(0, bytesRead));
  // Or buffer.Slice(0, bytesRead).Span
}
static int Checksum(Span<byte> buffer) { ... }

stackalloc 表达式

stackalloc 能在堆栈上分配内存块，分配的内存块不会被 GC 自动回收，生命周期仅限当前方法内

默认变量类型为指针，是不安全代码。但是可以将变量赋值给 Span<T> 或 ReadOnlySpan<T> 即为安全代码

1
2
3
4

unsafe
{
    var nums = stackalloc int[10]; // int* 类型, unsafe
}

1

Span<int> nums = stackalloc int[10]; // safe

可以和定义数组一样赋初值

1
2
3

Span<int> first = stackalloc int[3] { 1, 2, 3 };
Span<int> second = stackalloc int[] { 1, 2, 3 };
ReadOnlySpan<int> third = stackalloc[] { 1, 2, 3 };

Span<T> 在字符串中的实践

Span<T> 的应用场景很广，这里只举例字符串，感受一下 Span<T> 的强大

Span<T> 对字符串的切片效率很高，在内存中不需要创建临时的字符串

比如对用户输入的表达式进行计算，这里仅简单的处理加法如 11+22

常规简单做法

使用 string.SubString，会在内存中生成临时字符串

如果在循环中执行次数很多，就会在堆中生成很多临时字符串

1
2
3
4
5

var text = "11+22";
var index = text.IndexOf('+');
var num1 = int.Parse(text[..index]);
var num2 = int.Parse(text[(index + 1)..]);
Console.WriteLine(num1 + num2); // 33

使用 Span<T> / ReadOnlySpan<T>

不会产生临时字符串，而且切片效率会高很多，没有给 GC 增加压力

1
2
3
4
5
6

var text = "11+22";
var index = text.IndexOf('+');
var span = text.AsSpan();
var num1 = int.Parse(span[..index]);
var num2 = int.Parse(span[(index + 1)..]);
Console.WriteLine(num1 + num2); // 33

List<T> 自增的影响

List<T> 自增会造成 Span<T> 引用的位置错误，因此是这里是一个坑

先创建容量为 10 的 List<int>，并赋初值，使用 CollectionsMarshal 创建一个 Span<int>，指向 List<int> 内存块

1
2
3
4
5
6
7

var list = new List<int>(10);
Console.WriteLine($"Capacity: {list.Capacity}"); // Capacity: 10
for (var i = 0; i < 10; i++)
{
    list.Add(i);
}
var span = CollectionsMarshal.AsSpan(list);

代码到这里，span 就是 list 中元素的所在的内存段，对 span[i] 的读写都和 list[i] 的读写都是操作同一段内存数据，一切正常

现在我们给 list 增加一个元素，list 长度超过容量 10，因此容量会自增到 20

1
2

list.Add(10);
Console.WriteLine($"Capacity: {list.Capacity}"); // Capacity: 20

此时，span 指向的仍然是原来的 list 内存段，但现在 list 已经通过自增变为了另一个新的内存段

那么现在 span 和 list 两个变量就不相干了，给 span[i] 和 list[i] 赋值都互不影响，span 就失去了作用和意义

从逻辑上说，这也算是一种内存泄漏，只是这段内存没有用，即使内存泄漏也没有影响，这段内存会随着 span 变量的回收而回收

1
2
3

span[0] = 100;
Console.WriteLine($"span[0]: {span[0]}"); // span[0]: 100
Console.WriteLine($"list[0]: {list[0]}"); // list[0]: 0

或

1
2
3

list[1] = 100;
Console.WriteLine($"span[1]: {span[1]}"); // span[1]: 0
Console.WriteLine($"list[1]: {list[1]}"); // list[1]: 100

环境要求

• Linux

安装 cerbot

1
2
3

sudo add-apt-repository ppa:certbot/certbot
sudo apt-get update
sudo apt-get install certbot

创建证书

这里是通过手动 dns 的方式验证域名

执行语句

1

sudo certbot certonly --manual --preferred-challenges dns

首次执行会让你输入安全邮箱

1
2

Enter email address (used for urgent renewal and security notices)
 (Enter 'c' to cancel):

然后同意几个协议，都输入 Y 并回车

同意协议后，需要输入域名，用空格分隔

1
2

Please enter the domain name(s) you would like on your certificate (comma and/or
space separated) (Enter 'c' to cancel):

输入域名后，等待验证 dns

1
2
3
4
5
6
7

Please deploy a DNS TXT record under the name:

_acme-challenge.domain.com.

with the following value:

68vo-beB0fF8csOEolL6ADkK-9FaqwaweaweUJfejSe

这时先按提示在云服务商添加 dns 的 TXT 记录，稍等片刻再回车

成功提示如下

1
2
3
4
5

Successfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/domain.com/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/domain.com/privkey.pem
This certificate expires on 2023-12-17.
These files will be updated when the certificate renews.

证书位置在

1

/etc/letsencrypt/live/domain.com

证书链不完整

Let’s Encrypt 创建的证书可能会出现证书链不完整的错误

需要修复一下证书链

浏览器打开 https://myssl.com/chain_download.html

选择 上传证书

编辑证书文件，将文件内容拷出来，粘贴到网页，再点击 获取证书链，即得到修复后的证书内容

证书转换

PEM -> PFX/PKCS12

1

openssl pkcs12 -export -out cert.pfx -inkey privkey1.pem -in cert1.pem -certfile chain1.pem

PFX/PKCS12 -> PEM

1

openssl pkcs12 -in cert.pfx -out cert.pem -nodes

书中演示代码主要以 JavaScript 为主

何时重构

书中提到一些代码的坏味道

神秘命名（Mysterious Name）

命名是编程中最难的两件事之一。正因为如此，修改命名可能是最常用的重构方法。如果你发现改名很难，那就说明代码设计有问题。当我们不能给一个模块，一个对象，一个函数，甚至一个变量找到合适名称的时候，往往说明我们对问题的理解还不够透彻，需要重新去挖掘问题的本质，对问题域进行重新分析和抽象。

重复代码（Duplicated Code）

同一类的两个函数含有相同的表达式，就应该提炼。

过长函数（Long Function）

活得最长，最好的程序，其中函数一般都很短。如果你觉得需要写注释，大部分情况就代表这个东西需要写进一个独立的函数里面，然后根据用途来命名比较好。条件表达式和循环往往也是提炼函数的信号。

过长参数列表（Long Parameter List）

使用类可以有效的缩短参数列表。如果多个函数有同样的几个参数，引入一个类就尤为有意义。

全局数据（Global Data）

全局数据仍然是最刺鼻的坏味道之一。它的问题是，全局数据在任何地方都可以被修改。所以正确的做法是将全局数据封装起来，用函数将其包起来，这样就知道那些地方修改了它。有少量的全局数据或者无妨，但数量越多，处理难度就会指数上升。（良药与毒药的区别在于剂量）

可变数据（Mutable Data）

核心是缩小作用域。可以通过封装变量来确保所有数据更新操作都通过很少几个函数来进行，使其更容易被监控。

发散式变化（Divergent Change）

发散式变化指某个模块因为不同的原因在不同的方向上发生变化。每次只关心一个上下文。找到引起发散式变化的原因，将它拆分出来。

霰弹式修改（Shotgun Surgery）

在每次修改的时候，应该只修改一处，而不是到处的修改。因为一个需求，需要修改 3 处代码，那么这就需要思考，这 3 处代码是否应该抽离出来。一个常用的策略就是使用内联（inline）重构代码把本不该分散的逻辑拽回一处。

依恋情结（Feature Envy）

模块化，力求代码分出区域，最大化区域内部交互，最小化区域间交互。如果两个模块交互频繁，它们应该合并在一起。

数据泥团（Data Clumps）

如果在多个类中，出现了很多相同项的数据，你需要想想是否要通过将数据提炼成类，来抽离出一个独立对象。建议新建类而非简单的结构体。

基本类型偏执（Primitive Obsession）

很多程序员不愿意创建对自己的问题域有用的基本类型，如钱，坐标，范围等。比如有程序员用字符串来表示电话号码，实际上你应该抽象出来一个电话号码对象。

重复的 switch（Repeated Switches）

尽量使用多态而非 switch。

循环语句（Loops）

我们应该用管道操作(如 filter 和 map)来替代循环，这样能更快的看清被处理的元素和处理他们的动作。

冗赘的元素（Lasy Element）

能简单的代码，尽量简单。未来变复杂的时候，再去考虑它。

夸夸其谈的通用性（Speculative Generality）

同上，能简单的代码，尽量简单。通用性？过早的优化是万恶之源

临时字段（Temporary Field）

临时字段指内部某个字段仅为某种特定情况而设。临时的字段不应该存在。你需要给他们搬个新家，把所有和临时变量相关的代码搬至那里。

过长的消息链（Message Chains）

如果你看到用户向一个对象请求另一个对象，然后再向后者请求另一个对象，然后再请求另一个对象，这就是消息链。消息链意味着客户端会耦合消息链的查找过程。应该将查找过程独立出一个函数。

中间人（Middle Man）

委托函数过多时，减少委托，移除中间人，让调用者直接访问目标类进行操作。

内幕交易（Insider Trading）

减少模块之间频繁的数据交换，并把这种交换放到明面上。

过大的类（Large Class）

当一个类代码行数太多或者功能职责太多的时候，拆掉它。两种拆分方法：提取新类，当大类的部分行为可以分解为一个单独的组件，则可以使用提取类的方式拆分。提取子类，当大类的部分行为可以以不同的方式实现或在极少数情况下使用，则可以使用提取子类方式拆分。

异曲同工的类（Alternative Classes with Different Interfaces）

两个类有着相同的功能，但方法名称不同。重命名方法，并去除掉不必要的重复代码。

纯数据类（Data Class）

纯数据类常常意味着行为被放在了错误的地方。处理数据的行为应该从客户端移至纯数据类中。

被拒绝的遗赠（Refused Bequest）

如果子类复用了父类的实现，就应该支持父类的接口。

注释（Comments）

注释是提示你，这个地方该重构啦。如果你觉得需要写注释的时候，请先重构，试着让所有注释都变得多余。

重构手法

提炼函数（Extract Function）

将独立逻辑的一段代码，提炼为一个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

function printOwing(invoice) {
  printBanner();
  let outstanding = calculateOutstanding();

  //print details
  console.log(`name: ${invoice.customer}`);
  console.log(`amount: ${outstanding}`);
}

function printOwing(invoice) {
  printBanner();
  let outstanding = calculateOutstanding();
  printDetails(outstanding);

  function printDetails(outstanding) {
    console.log(`name: ${invoice.customer}`);
    console.log(`amount: ${outstanding}`);
  }
}

提炼函数的动机：将意图与实现分开

内联函数（Inline Function）

将函数中的代码直接写在调用处

1
2
3
4
5
6
7
8
9
10
11

function getRating(driver) {
  return moreThanFiveLateDeliveries(driver) ? 2 : 1;
}

function moreThanFiveLateDeliveries(driver) {
  return driver.numberOfLateDeliveries > 5;
}

function getRating(driver) {
  return driver.numberOfLateDeliveries > 5 ? 2 : 1;
}

提炼变量（Extract Variable）

分解复杂表达式，用局部变量分解表达式

1
2
3
4
5
6
7
8
9
10
11

return (
  order.quantity * order.itemPrice -
  Math.max(0, order.quantity - 500) * order.itemPrice * 0.05 +
  Math.min(order.quantity * order.itemPrice * 0.1, 100)
);

const basePrice = order.quantity * order.itemPrice;
const quantityDiscount =
  Math.max(0, order.quantity - 500) * order.itemPrice * 0.05;
const shipping = Math.min(basePrice * 0.1, 100);
return basePrice - quantityDiscount + shipping;

内联变量（Inline Variable）

消除表现力不好的变量

1
2

let basePrice = anOrder.basePrice;
return basePrice > 1000;

1

return anOrder.basePrice > 1000;

改变函数声明（Change Function Declaration）

函数改名，函数名应表达其作用

1

function circum(radius) {...}

1

function circumference(radius) {...}

封装变量（Encapsulate Variable）

避免直接修改全局数据，以函数形式封装对该数据的访问

1

let defaultOwner = { firstName: "Martin", lastName: "Fowler" };

1
2
3
4
5
6
7

let defaultOwnerData = { firstName: "Martin", lastName: "Fowler" };
export function defaultOwner() {
  return defaultOwnerData;
}
export function setDefaultOwner(arg) {
  defaultOwnerData = arg;
}

变量改名（Rename Variable）

将变量名改为易解释的名称

1

let a = height * width;

1

let area = height * width;

引入参数对象（Introduce Parameter Object）

将一组参数，合并为一个对象进行传参

1
2
3

function amountInvoiced(startDate, endDate) {...}
function amountReceived(startDate, endDate) {...}
function amountOverdue(startDate, endDate) {...}

1
2
3

function amountInvoiced(aDateRange) {...}
function amountReceived(aDateRange) {...}
function amountOverdue(aDateRange) {...}

函数组合成类（Combine Functions into Class）

用面向对象的的方式，组合一组函数

1
2
3

function base(aReading) {...}
function taxableCharge(aReading) {...}
function calculateBaseCharge(aReading) {...}

1
2
3
4
5

class Reading {
  base() {...}
  taxableCharge() {...}
  calculateBaseCharge() {...}
}

函数组合成变换（Combine Functions into Transform）

将一组函数组合为一个函数，返回结果组合成对象

1
2

function base(aReading) {...}
function taxableCharge(aReading) {...}

1
2
3
4
5
6

function enrichReading(argReading) {
  const aReading = _.cloneDeep(argReading);
  aReading.baseCharge = base(aReading);
  aReading.taxableCharge = taxableCharge(aReading);
  return aReading;
}

拆分阶段（Split Phase）

将一段代码，根据处理的事不同，拆分为多个函数

1
2
3

const orderData = orderString.split(/\s+/);
const productPrice = priceList[orderData[0].split("-")[1]];
const orderPrice = parseInt(orderData[1]) * productPrice;

1
2
3
4
5
6
7
8
9
10
11
12
13

const orderRecord = parseOrder(order);
const orderPrice = price(orderRecord, priceList);

function parseOrder(aString) {
  const values = aString.split(/\s+/);
  return {
    productID: values[0].split("-")[1],
    quantity: parseInt(values[1]),
  };
}
function price(order, priceList) {
  return order.quantity * priceList[order.productID];
}

C# 5

随 Visual Studio 2012 发布

异步 async/await

1
2
3
4
5

async Task Func() {
  return await Task.Run(() => {

  });
}

调用方信息特征

可以通过特性，在函数参数，取得调用方信息

• CallerMemberName 调用者函数名/属性名等
• CallerFilePath 调用者文件地址
• CallerLineNumber 调用者代码行数

C# 6

随 Visual Studio 2015 发布

using 静态引入

可以 using 引入类的静态成员

1

using static namespace.Class;

引入后可直接访问该类中的静态成员

using 引入别名

可以给引入的命名空间取别名

1
2
3

using name = namespace.subnamespace;

var obj = name.Class();

异常筛选器

支持异常的条件过滤

1
2
3
4
5
6
7
8

try
{

}
catch (Exception e) when (e.Message.StartsWith("demo"))
{

}

自动属性初始化表达式

为属性赋初始值

1

public static int Id { get; set; } = 123;

Expression-bodied 成员

用 Lambda 表达式定义类成员

只读属性

1

public static DateTime Time => DateTime.Now;

get/set 属性

1
2
3
4
5

public string Name
{
  get => name;
  set => name = value;
}

无返回值方法

1

public void Func(int id) => this.Id = id;

有返回值方法

1

public int Func(int id) => id + 1;

构造函数

1
2
3
4

public class Location
{
   public Location(string name) => this.Name = name;
}