前面定义的一些类也要改一下。

先是 MyConfigurationProvider 的构造函数。

public class MyConfigurationProvider : ConfigurationProvider, IDisposable { private System.Threading.Timer theTimer; private string connectString; public MyConfigurationProvider(string cnnstr) { connectString = cnnstr; …… } …… }

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

public class DemoConfigDBContext : DbContext { private string connStr; public DemoConfigDBContext(string connectionString) { connStr = connectionString; } …… protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseSqlServer(connStr); } }

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

{ "Logging": { …… }, "AllowedHosts": "*", "ConnectionStrings": { "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" } }

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

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

其他的不变。

-----------------------------------------------------------------------------------------------------

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

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

internal class TestForm : Form { private IDisposable _changeTokenReg; private TextBox _txtMsg; public TestForm(Func<IChangeToken?> getToken) { // 初始化子级控件 _txtMsg = new() { Dock = DockStyle.Fill, Margin = new Padding(5), Multiline = true, ScrollBars = ScrollBars.Vertical }; Controls.Add(_txtMsg); _changeTokenReg = ChangeToken.OnChange(getToken, OnCallback); } // 回调方法 void OnCallback() { DateTime curtime = DateTime.Now; string str = $"{curtime.ToLongTimeString()} 新年快乐\r\n"; _txtMsg.BeginInvoke(() => { _txtMsg.AppendText(str); }); } protected override void Dispose(bool disposing) { // 释放对象 if (disposing) { _changeTokenReg?.Dispose(); } base.Dispose(disposing); } }

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

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

上述例子用的是第一个，其实里面调用的也是第二个重载，只是把咱们传递的 OnCallback 方法当作 TState 传进去了。

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

public static IDisposable OnChange<TState>(Func<IChangeToken?> changeTokenProducer, Action<TState> changeTokenConsumer, TState state) { if (changeTokenProducer is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.changeTokenProducer); } if (changeTokenConsumer is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.changeTokenConsumer); } return new ChangeTokenRegistration<TState>(changeTokenProducer, changeTokenConsumer, state); }

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

private void OnChangeTokenFired() { // The order here is important. We need to take the token and then apply our changes BEFORE // registering. This prevents us from possible having two change updates to process concurrently. // // If the token changes after we take the token, then we'll process the update immediately upon // registering the callback. IChangeToken? token = _changeTokenProducer(); try { _changeTokenConsumer(_state); } finally { // We always want to ensure the callback is registered RegisterChangeTokenCallback(token); } } private void RegisterChangeTokenCallback(IChangeToken? token) { if (token is null) { return; } IDisposable registraton = token.RegisterChangeCallback(s => ((ChangeTokenRegistration<TState>?)s)!.OnChangeTokenFired(), this); if (token.HasChanged && token.ActiveChangeCallbacks) { registraton?.Dispose(); return; } SetDisposable(registraton); }

在 ChangeTokenRegistration 类的构造函数中，先调用 RegisterChangeTokenCallback 方法，开始了整个递归套娃的过程。在 RegisterChangeTokenCallback 方法中，为 token 注册的回调就是调用 OnChangeTokenFired 方法。

而 OnChangeTokenFired 方法中，是先获取新的 Change Token，再触发旧 token。最后，又调用 RegisterChangeTokenCallback 方法，实现了无限套娃的逻辑。

因此，咱们在用的时候，必须先创建新的 Change Token 实例，然后再调用 RegisterChangeTokenCallback 实例的 Cancel 方法。不然这无限套娃会一直进行到栈溢出，除非你提前把 ChangeTokenRegistration 实例 Dispose 掉（由 OnChange 静态方法返回）。可是那样的话，你就不能多次接收更改了。

下面就是主窗口部分，也是最危险的部分——必须按照咱们上面分析的顺序进行，不然会 Stack Overflow。

public partial class Form1 : Form { private CancellationTokenSource _cancelTkSource; private CancellationChangeToken _changeToken; public Form1() { InitializeComponent(); _cancelTkSource = new CancellationTokenSource(); _changeToken = new(_cancelTkSource.Token); button1.Click += OnButton1Click; button2.Click += OnButton2Click; } private void OnButton2Click(object? sender, EventArgs e) { for(int t= 0; t < 5; t++) { TestForm frm = new(GetChangeToken); frm.Text = "窗口" + (t + 1); frm.Size = new Size(300, 240); frm.StartPosition = FormStartPosition.CenterParent; frm.Show(this); } } // 这个地方就是触发token了，所以要先换上新的实例 private void OnButton1Click(object? sender, EventArgs e) { // 先创建新的实例 var oldsource = Interlocked.Exchange(ref _cancelTkSource, new CancellationTokenSource()); Interlocked.Exchange(ref _changeToken, new CancellationChangeToken(_cancelTkSource.Token)); // 只要CancellationTokenSource一取消，其他客户端会收到通知 oldsource.Cancel(); } // 这个方法传递给 TestForm 构造函数，再传给 OnChange 静态方法 public IChangeToken? GetChangeToken() { return _changeToken; } }