在自定义ASP.NET Core配置提供程序中停止SqlDependency

Question

我已按照此处的说明编写了一个自定义配置提供程序，以从数据库表加载ASP.NET Core配置：

ASP.Net自定义配置提供程序

SqlDependency如果数据库中的值发生更改，我的提供程序将用于重新加载配置。

该文档的SqlDependency规定：

必须为每个Start调用调用Stop方法。给定的侦听器仅在收到与启动请求相同数量的停止请求时才完全关闭。

我不确定如何在ASP.NET Core的自定义配置提供程序中执行此操作。

下面是代码：

DbConfigurationSource

基本上是一个容器，IDbProvider用于处理从数据库中检索数据

public class DbConfigurationSource : IConfigurationSource
{
    /// <summary>
    /// Used to access the contents of the file.
    /// </summary>
    public virtual IDbProvider DbProvider { get; set; }


    /// <summary>
    /// Determines whether the source will be loaded if the underlying data changes.
    /// </summary>
    public virtual bool ReloadOnChange { get; set; }

    /// <summary>
    /// Will be called if an uncaught exception occurs in FileConfigurationProvider.Load.
    /// </summary>
    public Action<DbLoadExceptionContext> OnLoadException { get; set; }

    public IConfigurationProvider Build(IConfigurationBuilder builder)
    {
        return new DbConfigurationProvider(this);
    }
}

DbConfigurationDataProvider

这是一个类，用于创建和监视SqlDependency数据库，并从数据库中加载数据。这也是该Dispose()电话是我想要Stop()的SqlDependency。Dispose()当前未调用。

public class DbConfigurationDataProvider : IDbProvider, IDisposable
{        
    private readonly string _applicationName;
    private readonly string _connectionString;

    private ConfigurationReloadToken _reloadToken;

    public DbConfigurationDataProvider(string applicationName, string connectionString)
    {
        if (string.IsNullOrWhiteSpace(applicationName))
        {
            throw new ArgumentNullException(nameof(applicationName));
        }

        if (string.IsNullOrWhiteSpace(connectionString))
        {
            throw new ArgumentNullException(nameof(connectionString));
        }

        _applicationName = applicationName;
        _connectionString = connectionString;

        _reloadToken = new ConfigurationReloadToken();

        SqlDependency.Start(_connectionString);
    }

    void OnDependencyChange(object sender, SqlNotificationEventArgs e)
    {
        var dependency = (SqlDependency)sender;
        dependency.OnChange -= OnDependencyChange;

        var previousToken = Interlocked.Exchange(
            ref _reloadToken,
            new ConfigurationReloadToken());

        previousToken.OnReload();
    }

    public IChangeToken Watch()
    {
        return _reloadToken;
    }

    public List<ApplicationSettingDto> GetData()
    {
        var settings = new List<ApplicationSettingDto>();

        var sql = "select parameter, value from dbo.settingsTable where application = @application";

        using (var connection = new SqlConnection(_connectionString))
        {
            using (var command = new SqlCommand(sql, connection))
            {
                command.Parameters.AddWithValue("application", _applicationName);

                var dependency = new SqlDependency(command);

                // Subscribe to the SqlDependency event.  
                dependency.OnChange += OnDependencyChange;

                connection.Open();

                using (var reader = command.ExecuteReader())
                {
                    var keyIndex = reader.GetOrdinal("parameter");
                    var valueIndex = reader.GetOrdinal("value");

                    while (reader.Read())
                    {
                        settings.Add(new ApplicationSettingDto
                            {Key = reader.GetString(keyIndex), Value = reader.GetString(valueIndex)});
                    }
                }
            }
        }

        Debug.WriteLine($"{DateTime.Now}: {settings.Count} settings loaded");

        return settings;
    }

    public void Dispose()
    {
        SqlDependency.Stop(_connectionString);
        Debug.WriteLine($"{nameof(WhsConfigurationProvider)} Disposed");
    }
}

DbConfigurationProvider

这个类监控changeToken中DbConfigurationDataProvider并发布新配置的应用程序。

public class DbConfigurationProvider : ConfigurationProvider
{
    private DbConfigurationSource Source { get; }

    public DbConfigurationProvider(DbConfigurationSource source)
    {
        Source = source ?? throw new ArgumentNullException(nameof(source));

        if (Source.ReloadOnChange && Source.DbProvider != null)
        {
            ChangeToken.OnChange(
                () => Source.DbProvider.Watch(),
                () =>
                {                        
                    Load(reload: true);
                });                
        }           
    }

    private void Load(bool reload)
    {
        // Always create new Data on reload to drop old keys
        if (reload)
        {
            Data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        }

        var settings = Source.DbProvider.GetData();

        try
        {
            Load(settings);
        }
        catch (Exception e)
        {
            HandleException(e);
        }

        OnReload();
    }

    public override void Load()
    {
        Load(reload: false);
    }

    public void Load(List<ApplicationSettingDto> settings)
    {
        Data = settings.ToDictionary(s => s.Key, s => s.Value, StringComparer.OrdinalIgnoreCase);                       
    }

    private void HandleException(Exception e)
    {
            // Removed for brevity
    }     
}

DbConfigurationExtensions

扩展方法调用以设置所有内容。

public static class DbConfigurationExtensions
{
    public static IConfigurationBuilder AddDbConfiguration(this IConfigurationBuilder builder, IConfiguration config, string applicationName = "")
    {
        if (string.IsNullOrWhiteSpace(applicationName))
        {
            applicationName = config.GetValue<string>("ApplicationName");
        }

        // DB Server and Catalog loaded from Environment Variables for now
        var server = config.GetValue<string>("DbConfigurationServer");
        var database = config.GetValue<string>("DbConfigurationDatabase");

        if (string.IsNullOrWhiteSpace(server))
        {
            // Removed for brevity
        }

        if (string.IsNullOrWhiteSpace(database))
        {
            // Removed for brevity
        }

        var sqlBuilder = new SqlConnectionStringBuilder
        {
            DataSource = server,
            InitialCatalog = database,
            IntegratedSecurity = true
        };

        return builder.Add(new DbConfigurationSource
        {
             DbProvider = new DbConfigurationDataProvider(applicationName, sqlBuilder.ToString()),                
             ReloadOnChange = true
        } );
    }
}

最后，调用以设置整个过程：

public class Program
{
    public static void Main(string[] args)
    {                        
        CreateWebHostBuilder(args).Build().Run();            
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((hostingContext, config) =>
    {
        config.AddDbConfiguration(hostingContext.Configuration, "TestApp");            
    }).UseStartup<Startup>();
}

总结一下：如何确保Dispose()在DbConfigurationDataProvider类中调用该方法？

到目前为止，我发现的唯一信息是从这里：https : //andrewlock.net/four-ways-to-dispose-idisposables-in-asp-net-core/

其中介绍了如何处置对象：

1. 在带有using语句的代码块内（不适用）
2. 在请求结束时（不适用）
3. 使用DI容器（不适用-我不认为吗？）
4. 当应用程序结束时<-听起来很有希望

选项4如下所示：

public void Configure(IApplicationBuilder app, IApplicationLifetime applicationLifetime,
                        SingletonAddedManually toDispose)
{
        applicationLifetime.ApplicationStopping.Register(OnShutdown, toDispose);

         // configure middleware etc
}

private void OnShutdown(object toDispose)
{
    ((IDisposable)toDispose).Dispose();
}

SingletonAddedManually在我的情况下将是DbConfigurationDataProvider该类，但这在该类的范围之外Startup。

有关IApplicationLifetime界面的更多信息：

https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/host/web-host?view=aspnetcore-2.2

编辑
这个例子甚至不打扰SqlDependency.Stop()，也许不是那么重要吗？

https://docs.microsoft.com/zh-cn/dotnet/framework/data/adonet/sql/sqldependency-in-an-aspnet-app

Answer 1

\ xe2 \x80\x9cproper\xe2\x80\x9d执行此操作的方法是让您的配置提供程序是一次性的，然后将所有SqlDependency对象作为配置提供程序处置的一部分进行处置。

\n\n

不幸的是，在 2.x 中，配置框架不支持一次性提供程序。但是，作为aspnet/Extensions#786和aspnet/Extensions#861的一部分，这可能会发生变化。

\n\n

由于我参与了这个开发，我可以自豪地宣布，从 3.0 开始，将支持一次性配置提供程序。

\n\n

在Microsoft.Extensions.Configuration3.0 中，当配置根被处置时，一次性提供程序将被正确处置。当（Web）主机被释放时，配置根将在 ASP.NET Core 3.0 中被释放。因此，最终，您的一次性配置提供程序将被正确处理，并且不应再泄漏任何内容。

\n