【.NET】聊聊 IChangeToken 接口

卫水宝通道店

由于两个月的奋战，导致很久没更新了。就是上回老周说的那个产线和机械手搬货的项目，好不容易等到工厂放假了，我就偷偷乐了。当然也过年了，老周先给大伙伴们拜年了，P话不多讲，就祝大家身体健康、生活愉快。其实生活和健康是密不可分的，想活得好，就得健康。包括身体健康、思想健康、心理健康、精神健康。不能以为我无病无痛就很健康，你起码要全方位健康。
不管你的工作是什么，忙或者不忙，报酬高或低，但是，人，总得活，总得过日子。咱们最好多给自己点福利，多整点可以自娱自乐的东西，这就是生活。下棋、打游戏、绘画、书法、钓鱼、飙车、唢呐……不管玩点啥，只要积极正向的就好，可以大大降低得抑郁症、高血压的机率；可以减少70%无意义的烦恼；可以降低跳楼风险；在这个礼崩乐坏的社会环境中，可以抵御精神污染……总之，益处是大大的有。
然后老周再说一件事，一月份的时候常去工厂调试，也认识了机械臂厂商派的技术支持——吴大工程师。由于工厂所处地段非常繁华，因此每次出差，午饭只能在附近一家四川小吃店解决。毕竟这方圆百十里也仅此一家。不去那里吃饭除非自带面包蹲马路边啃，工厂不供食也不供午休场所。刚开始几次出差还真的像个傻子似的蹲马路边午休。后来去多了，直接钻进工厂的会议室睡午觉。
有一天吃午饭时，吴老师说：你说什么样的人编程水平最高？
我直接从潜意识深处回答他：我做一个排序，仅供参考。编程水平从高到低排行：
1、黑客。虽然大家都说黑客一代不如一代，但目前来说，这群人还是最强的；
2、纯粹技术爱好者；
3、著名开源项目贡献者。毕竟拿不出手的代码也不好意思与人分享；
4、做过许多项目的一线开发者。我强调的项目数量多，而不是长年只维护一个项目的。只有数量多你学到的才多；
5、社区贡献较多者，这个和3差不多。不过，老周认为的社区贡献就是不仅提供代码，还提供文档、思路、技巧等；
6、刚入坑但基础较好的开发者；
7、培训机构的吹牛专业户；
8、大学老师/教授；
9、短视频平台上的砖家、成宫人士；
10、刚学会写 main 函数的小朋友。
==========================================================================================================
下面进入主题，咱们今天聊聊 IChangeToken。它的主要功能是提供更改通知。比如你的配置源发生改变了，要通知配置的使用者重新加载。你可能会疑惑，这货跟使用事件有啥区别？这个老周也不好下结论，应该是为异步代码准备的吧。
下面是 IChangeToken 接口的成员：

1. bool HasChanged { get; }
2. bool ActiveChangeCallbacks { get; }
3. IDisposable RegisterChangeCallback(Action<object?> callback, object? state);

复制代码

这个 Change Token 思路很清奇，实际功能类似事件，就是更改通知。咱们可以了解一下其原理，但如果你觉得太绕，不想了解也没关系的。在自定义配置源时，咱们是不需要自己写 Change Token 的，框架已有现成的。我们只要知道要触发更改通知时调用相关成员就行。
如果你想看源码的话，老周可以告你哪些文件（github 项目是 dotnet\runtime）：
1、runtime-main\src\libraries\Common\src\Extensions\ChangeCallbackRegistrar.cs：这个主要是 UnsafeRegisterChangeCallback 方法，用于注册回调委托；
2、runtime-main\src\libraries\Microsoft.Extensions.Primitives\src\ChangeToken.cs：这个类主要是提供静态的辅助方法，用于注册回调委托。它的好处是可以循环——注册回调后，触发后委托被调用；调用完又自动重新注册，使得 Change Token 可以多次触发；
3、runtime-main\src\libraries\Microsoft.Extensions.Primitives\src\CancellationChangeToken.cs：这个类是真正实现 IChangeToken 接口的；
4、runtime-main\src\libraries\Microsoft.Extensions.Configuration\src\ConfigurationReloadToken.cs：这个也是实现 IChangeToken 接口，而且它才是咱们今天的主角，该类就是为重新加载配置数据而提供的。调用它的 OnReload 方法可以触发更改通知。
看了上面这些，你可能更疑惑了。啥原理？为啥 Token 只能触发一次？为何要重新注册回调？
咱们用一个简单例子演练一下。

1. static void Main(string[] args)
2. {
3.     CancellationTokenSource cs = new();
4.     // 这里获取token
5.     CancellationToken token = cs.Token;
6.     // token 可以注册回调
7.     token.Register(() =>
8.     {
9.         Console.WriteLine("你按下了【K】键");
10.     });
11.     // 启动一个新task
12.     Task myTask = Task.Run(() =>
13.     {
14.         // 等待输入，如果按下【K】键，就让CancellationTokenSource取消
15.         ConsoleKeyInfo keyInfo;
16.         while(true)
17.         {
18.             keyInfo = Console.ReadKey(true);
19.             if(keyInfo.Key == ConsoleKey.K)
20.             {
21.                 // 取消
22.                 cs.Cancel();
23.                 break;
24.             }
25.         }
26.     });
27.     // 主线程等待任务完成
28.     Task.WaitAll(myTask);
29. }

复制代码

CancellationTokenSource 类表示一个取消任务的标记，访问它的 Token 属性可以获得一个 CancellationToken 结构体实例，可以检索它的 IsCancellationRequested 属性以明确是否有取消请求（有则true，无则false）。
还有更重要的，CancellationToken 结构体的 Register 方法可以注册一个委托作为回调，当收到取消请求后会触发这个委托。对的，这个就是 Change Token 灵魂所在了。一旦回调被触发后，CancellationTokenSource 就处于取消状态了，你无法再次触发，除非重置或重新实例化。这就是回调只能触发一次的原因。
下面，咱们完成一个简单的演示——用数据库做配置源。在 SQL Server 里面随便建个数据库，然后添加一个表，名为 tb_configdata。它有四个字段：

1. CREATE TABLE [dbo].[tb_configdata](
2.     [ID] [int] NOT NULL,
3.     [config_key] [nvarchar](15) NOT NULL,
4.     [config_value] [nvarchar](30) NOT NULL,
5.     [remark] [nvarchar](50) NULL,
6. CONSTRAINT [PK_tb_configdata] PRIMARY KEY CLUSTERED
7. (
8.     [ID] ASC,
9.     [config_key] ASC
10. )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
11. ) ON [PRIMARY]
12. GO

复制代码

ID和config_key设为主键，config_value 是配置的值，remark 是备注。备注字段其实可以不用，但实际应用的时候，可以用来给配置项写点注释。
然后，在程序里面咱们用到 EF Core，故要先生成与表对应的实体类。这里老周就不用工具了，直接手写更有效率。

1. // 实体类
2. public class MyConfigData
3. {
4.     public int ID { get; set; }
5.     public string ConfigKey { get; set; } = string.Empty;
6.     public string ConfigValue { get; set; } = string.Empty;
7.     public string? Remark { get; set; }
8. }
10. // 数据库上下文对象
11. public class DemoConfigDBContext : DbContext
12. {
13.     public DbSet<MyConfigData> ConfigData => Set<MyConfigData>();
15.     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
16.     {
17.         optionsBuilder.UseSqlServer("Data Source=DEV-PC\\SQLTEST;Initial Catalog=Demo;Integrated Security=True;Connect Timeout=30;Encrypt=True;Trust Server Certificate=True;Application Intent=ReadWrite;Multi Subnet Failover=False");
18.     }
20.     protected override void OnModelCreating(ModelBuilder modelbd)
21.     {
22.         modelbd.Entity<MyConfigData>()
23.             .ToTable("tb_configdata")
24.             .HasKey(c => new { c.ID, c.ConfigKey });
25.         modelbd.Entity<MyConfigData>()
26.             .Property(c => c.ConfigKey)
27.             .HasColumnName("config_key");
28.         modelbd.Entity<MyConfigData>()
29.             .Property(c => c.ConfigValue)
30.             .HasColumnName("config_value");
31.         modelbd.Entity<MyConfigData>()
32.             .Property(c => c.Remark)
33.             .HasColumnName("remark");
34.     }
35. }

复制代码

上述代码的情况特殊，实体类的名称和成员名称与数据表并不一致，所以在重写 OnModelCreating 方法时，需要进行映射。
1、ToTable("tb_configdata") 告诉 EF 实体类对应的数据表是 tb_configdata；
2、HasKey(c => new { c.ID, c.ConfigKey })：表明该实体有两个主键——ID和ConfigKey。这里指定的是实体类的属性，而不是数据表的字段名，因为后面咱们会进行列映射；
3、HasColumnName("config_key")：告诉 EF，实体的 ConfigKey 属性对应的是数据表中 config_key。后面的几个属性的道理一样，都是列映射。
做映射就类似于填坑，如果你不想挖坑，那就直接让实体类名与表名一样，属性名与表字段（列）一样，这样就省事多了。不过，在实际使用中真没有那么美好。很多时候数据库是小李负责的，人家早就建好了，存储过程都写了几万个了。后面前台程序是老张来开发，对老张来说，要么把实体的命名与数据库的一致，要么就做一下映射。多数情况下是要映射的，毕竟很多时候数据库对象的命名都比较奇葩。尤其有上千个表的时候，为了看得顺眼，很多人喜欢这样给数据表命名：ta_XXX、ta_YYY、tb_ZZZ、tc_FFF、tx_PPP、ty_EEE、tz_WWW。还有这样命名的：m1_Report、m2_ReportDetails…… m105_TMD、m106_WNM、m107_DOUBI。
这种命名用在实体类上面确实很不优雅，所以映射就很必要了。
此处咱们不用直接实现 IConfigurationProvider 接口，而是从 ConfigurationProvider 类派生就行了。自定义配置源的东东老周以前写过，只是当时没有实现更改通知。

1. public class MyConfigurationProvider : ConfigurationProvider, IDisposable
2. {
3.     private System.Threading.Timer theTimer;
5.     public MyConfigurationProvider()
6.     {
7.         theTimer = new Timer(OnTimer, null, 100, 10000);
8.     }
10.     private void OnTimer(object? state)
11.     {
12.         // 先调用Load方法，然后用OnReload触发更新通知
13.         Load();
14.         OnReload();
15.     }
17.     public void Dispose()
18.     {
19.         theTimer?.Change(0, 0);
20.         theTimer?.Dispose();
21.     }
23.     public override void Load()
24.     {
25.         // 先读取一下
26.         using DemoConfigDBContext dbctx = new();
27.         // 如果无数据，先初始化
28.         if(dbctx.ConfigData.Count() == 0)
29.         {
30.             InitData(dbctx.ConfigData);
31.         }
32.         // 加载数据
33.         Data = dbctx.ConfigData.ToDictionary(k => k.ConfigKey, k => (string?)k.ConfigValue);
35.         // 本地函数
36.         void InitData(DbSet<MyConfigData> set)
37.         {
38.             int _id = 1;
39.             set.Add(new()
40.             {
41.                 ID = _id,
42.                 ConfigKey = "page_size",
43.                 ConfigValue = "25"
44.             });
45.             _id += 1;
46.             set.Add(new()
47.             {
48.                 ID = _id,
49.                 ConfigKey = "format",
50.                 ConfigValue = "xml"
51.             });
52.             _id += 1;
53.             set.Add(new()
54.             {
55.                 ID = _id,
56.                 ConfigKey = "limited_height",
57.                 ConfigValue = "1450"
58.             });
59.             _id += 1;
60.             set.Add(new()
61.             {
62.                 ID = _id,
63.                 ConfigKey = "msg_lead",
64.                 ConfigValue = "TDXA_"
65.             });
66.             // 保存数据
67.             dbctx.SaveChanges();
68.         }
69.     }
71. }

复制代码

由于老周不知道怎么监控数据库更新，最简单的办法就是用定时器循环检查。重点是重写 Load 方法，完成加载配置的逻辑。Load 方法覆写后不需要调用 base 的 Load 方法，因为基类的方法是空的，调用了也没毛用。
在 Timer 对象调用的方法（OnTimer）中，先调用 Load 方法，再调用 OnReload 方法。这样就可以在加载数据后触发更改通知。
然后实现 IConfigurationSource 接口，提供 MyConfigurationProvider 实例。

1. public class MyConfigurationSource : IConfigurationSource
2. {
3.     public IConfigurationProvider Build(IConfigurationBuilder builder)
4.     {
5.         return new MyConfigurationProvider();
6.     }
7. }

复制代码

默认的配置源有JSON文件、命令行、环境变量等，为了排除干扰，便于查看效果，在 Main 方法中咱们先把配置源列表清空，再添加咱们自定义的配置源。

1. var builder = WebApplication.CreateBuilder(args);
2. // 清空配置源
3. builder.Configuration.Sources.Clear();
4. // 添加配置源到Sources
5. builder.Configuration.Sources.Add(new MyConfigurationSource());
6. var app = builder.Build();

复制代码

最后，可以做个简单测试，直接注入 Mini-API 中读取配置。

1. app.MapGet("/", (IConfiguration config) =>
2. {
3.     StringBuilder bd = new();
4.     foreach(var kp in config.AsEnumerable())
5.     {
6.         bd.AppendLine($"{kp.Key} = {kp.Value}");
7.     }
8.     return bd.ToString();
9. });

复制代码

运行效果如下：

这时候咱们到数据库里把配置值改一下。

1. update tb_configdata
2.     set config_value = N'55'
3.     where config_key = N'page_size'
5. update tb_configdata
6.     set config_value = N'1900'
7.     where config_key = N'limited_height'

复制代码

接着回应用程序的页面，刷新一下，配置值已更新。

这里你可能会有个疑问：连接字符串硬编码了不太好，要不写在配置文件中，可是，写在JSON文件中咱们怎么获取呢？毕竟 ConfigurationProvider 不使用依赖注入。
IConfigurationSource 不是有个 Build 方法吗？Build 方法不是有个参数是 IConfigurationBuilder 吗？用它，用它，狠狠地用它。

1. public class MyConfigurationSource : IConfigurationSource
2. {
3.     public IConfigurationProvider Build(IConfigurationBuilder builder)
4.     {
5.         // 此处可以临时build一个配置树，就能获取到JSON配置文件里面的连接字符串了
6.         var config = builder.Build();
7.         string connStr = config["ConnectionStrings:test"]!;
8.         return new MyConfigurationProvider(connStr);
9.     }
10. }

复制代码

前面定义的一些类也要改一下。
先是 MyConfigurationProvider 的构造函数。

1. public class MyConfigurationProvider : ConfigurationProvider, IDisposable
2. {
3.     private System.Threading.Timer theTimer;
4.     private string connectString;
6.     public MyConfigurationProvider(string cnnstr)
7.     {
8.         connectString = cnnstr;
9.         ……
10.     }
12.     ……
13. }

复制代码

DemoConfigDBContext 类是连接字符串的最终使用者，所以也要改一下。

1. public class DemoConfigDBContext : DbContext
2. {
3.     private string connStr;
5.     public DemoConfigDBContext(string connectionString)
6.     {
7.         connStr = connectionString;
8.     }
10.     ……
12.     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
13.     {
14.         optionsBuilder.UseSqlServer(connStr);
15.     }
16. }

复制代码

在appsettings.json 文件中配置连接字符串。

1. {
2.   "Logging": {
3.     ……
4.   },
5.   "AllowedHosts": "*",
6.   "ConnectionStrings": {
7.     "test": "Data Source=DEV-PC\\SQLTEST;Initial Catalog=Demo;Integrated Security=True;Connect Timeout=30;Encrypt=True;Trust Server Certificate=True;Application Intent=ReadWrite;Multi Subnet Failover=False"
8.   }
9. }

复制代码

回到 Main 方法，咱们还得加上 JSON 配置源。

1. var builder = WebApplication.CreateBuilder(args);
2. // 清空配置源
3. builder.Configuration.Sources.Clear();
4. // 添加配置源到Sources
5. builder.Configuration.AddJsonFile("appsettings.json");
6. builder.Configuration.Sources.Add(new MyConfigurationSource());
7. var app = builder.Build();

复制代码

其他的不变。
-----------------------------------------------------------------------------------------------------
接下来，咱们弄个一对多的例子。逻辑是这样的：启动程序显示主窗口，接着创建五个子窗口。主窗口上有个大大的按钮，点击后，五个子窗口会收到通知。大概就这个样子：

子窗口名为 TextForm，代码如下：

1. internal class TestForm : Form
2. {
3.     private IDisposable _changeTokenReg;
4.     private TextBox _txtMsg;
5.     public TestForm(Func<IChangeToken?> getToken)
6.     {
7.         // 初始化子级控件
8.         _txtMsg = new()
9.         {
10.             Dock = DockStyle.Fill,
11.             Margin = new Padding(5),
12.             Multiline = true,
13.             ScrollBars = ScrollBars.Vertical
14.         };
15.         Controls.Add(_txtMsg);
17.         _changeTokenReg = ChangeToken.OnChange(getToken, OnCallback);
18.     }
20.     // 回调方法
21.     void OnCallback()
22.     {
23.         DateTime curtime = DateTime.Now;
24.         string str = $"{curtime.ToLongTimeString()} 新年快乐\r\n";
25.         _txtMsg.BeginInvoke(() =>
26.         {
27.             _txtMsg.AppendText(str);
28.         });
29.     }
31.     protected override void Dispose(bool disposing)
32.     {
33.         // 释放对象
34.         if (disposing)
35.         {
36.             _changeTokenReg?.Dispose();
37.         }
38.         base.Dispose(disposing);
39.     }
40. }

复制代码

窗口上只放了一个文本框。上面代码中，使用了 ChangeToken.OnChange 静态方法，为 Change Token 注册回调委托，本例中回调委托绑定的是 OnCallback 方法，也就是说：当 Change Token 触发后会在文本框中追加文本。OnChange 静态方法有两个重载：

1. // 咱们示例中用的是这个版本
2. static IDisposable OnChange(Func<IChangeToken?> changeTokenProducer, Action changeTokenConsumer);
3. // 这是另一个重载
4. static IDisposable OnChange<TState>(Func<IChangeToken?> changeTokenProducer, Action<TState> changeTokenConsumer, TState state);

复制代码

上述例子用的是第一个，其实里面调用的也是第二个重载，只是把咱们传递的 OnCallback 方法当作 TState 传进去了。
请大伙伴暂时记住 changeTokenProducer 和 changeTokenConsumer 这两参数。changeTokenProducer 也是一个委托，返回 IChangeToken。用的时候一定要注意，每次触发之前，Change Token 要先创建新实例。注意是先创建新实例再触发，否则会导致无限。尽管内部会判断 HasChanged 属性，可问题是这个判断是在注册回调之后的。这个是跟 Change Token 的清奇逻辑有关，咱们看看 OnChage 的源代码就明白了。

1. public static IDisposable OnChange<TState>(Func<IChangeToken?> changeTokenProducer, Action<TState> changeTokenConsumer, TState state)
2. {
3.      if (changeTokenProducer is null)
4.      {
5.          ThrowHelper.ThrowArgumentNullException(ExceptionArgument.changeTokenProducer);
6.      }
7.      if (changeTokenConsumer is null)
8.      {
9.          ThrowHelper.ThrowArgumentNullException(ExceptionArgument.changeTokenConsumer);
10.      }
12.      return new ChangeTokenRegistration<TState>(changeTokenProducer, changeTokenConsumer, state);
13. }

复制代码

简单来说，就是返回一个 ChangeTokenRegistration 实例，这是个私有类，咱们是访问不到的，以 IDisposable 接口公开。其中，它有两个方法是递归调用的：

1. private void OnChangeTokenFired()
2. {
3.     // The order here is important. We need to take the token and then apply our changes BEFORE
4.     // registering. This prevents us from possible having two change updates to process concurrently.
5.     //
6.     // If the token changes after we take the token, then we'll process the update immediately upon
7.     // registering the callback.
8.     IChangeToken? token = _changeTokenProducer();
10.     try
11.     {
12.         _changeTokenConsumer(_state);
13.     }
14.     finally
15.     {
16.         // We always want to ensure the callback is registered
17.         RegisterChangeTokenCallback(token);
18.     }
19. }
21. private void RegisterChangeTokenCallback(IChangeToken? token)
22. {
23.     if (token is null)
24.     {
25.         return;
26.     }
27.     IDisposable registraton = token.RegisterChangeCallback(s => ((ChangeTokenRegistration<TState>?)s)!.OnChangeTokenFired(), this);
28.     if (token.HasChanged && token.ActiveChangeCallbacks)
29.     {
30.         registraton?.Dispose();
31.         return;
32.     }
33.     SetDisposable(registraton);
34. }

复制代码

在 ChangeTokenRegistration 类的构造函数中，先调用 RegisterChangeTokenCallback 方法，开始了整个递归套娃的过程。在 RegisterChangeTokenCallback 方法中，为 token 注册的回调就是调用 OnChangeTokenFired 方法。
而 OnChangeTokenFired 方法中，是先获取新的 Change Token，再触发旧 token。最后，又调用 RegisterChangeTokenCallback 方法，实现了无限套娃的逻辑。
因此，咱们在用的时候，必须先创建新的 Change Token 实例，然后再调用 RegisterChangeTokenCallback 实例的 Cancel 方法。不然这无限套娃会一直进行到栈溢出，除非你提前把 ChangeTokenRegistration 实例 Dispose 掉（由 OnChange 静态方法返回）。可是那样的话，你就不能多次接收更改了。
下面就是主窗口部分，也是最危险的部分——必须按照咱们上面分析的顺序进行，不然会 Stack Overflow。

1. public partial class Form1 : Form
2. {
3.     private CancellationTokenSource _cancelTkSource;
4.     private CancellationChangeToken _changeToken;
5.     public Form1()
6.     {
7.         InitializeComponent();
8.         _cancelTkSource = new CancellationTokenSource();
9.         _changeToken = new(_cancelTkSource.Token);
10.         button1.Click += OnButton1Click;
11.         button2.Click += OnButton2Click;
12.     }
14.     private void OnButton2Click(object? sender, EventArgs e)
15.     {
16.         for(int t= 0; t < 5; t++)
17.         {
18.             TestForm frm = new(GetChangeToken);
19.             frm.Text = "窗口" + (t + 1);
20.             frm.Size = new Size(300, 240);
21.             frm.StartPosition = FormStartPosition.CenterParent;
22.             frm.Show(this);
23.         }
24.     }
26.     // 这个地方就是触发token了，所以要先换上新的实例
27.     private void OnButton1Click(object? sender, EventArgs e)
28.     {
29.         // 先创建新的实例
30.         var oldsource = Interlocked.Exchange(ref _cancelTkSource, new CancellationTokenSource());
31.         Interlocked.Exchange(ref _changeToken, new CancellationChangeToken(_cancelTkSource.Token));
32.         // 只要CancellationTokenSource一取消，其他客户端会收到通知
33.         oldsource.Cancel();
34.     }
36.     // 这个方法传递给 TestForm 构造函数，再传给 OnChange 静态方法
37.     public IChangeToken? GetChangeToken()
38.     {
39.         return _changeToken;
40.     }
41. }

复制代码

按钮1的单击事件处理方法就是触发点，所以，CancellationTokenSource、CancellationChangeToken 要先换成新的实例，然后再用旧的实例去 Cancel。这里用 Interlocked 类会好一些，毕竟要考虑异步的情况，虽然咱这里都是在UI线程上传递的，但还是遵守这个习惯好一些。
这样处理就能避免栈溢出了。运行后，先打开五个子窗口（多点击一次就能创建十个子窗口）。接着点击大大按钮，五个子窗口就能收到通知了。

 
好了，这次就聊到这儿了。

来源:https://www.cnblogs.com/tcjiaan/p/18012397
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！