确保在DISPOSE上订阅EventHandler

Question

我正在订阅构造函数中的EventHandler，并在Dispose方法中取消订阅。对我而言，重要的是要确保此事件在Dispose时取消订阅，即使用户忘记调用它，也可以调用IE处置。

我添加了一个解构器，如果用户忘记了，它应该调用Dispose方法，但是当我对其进行断点时，似乎并没有。

// Program.cs
// this scope is on purpose to make sure it's disposed
{
    var client = new DeribitClient(DeribitEndpointType.Productive);
}

Console.ReadLine();

// Client.cs
public sealed class Client : IDisposable
{
    private readonly WebSocketClient _client;

    public Client()
    {
        _client = new WebSocketClient("wss://...");
        _client.MessageReceived += OnMessageReceived;
    }

    public void Dispose()
    {
        _client.MessageReceived -= OnMessageReceived;

        GC.SuppressFinalize(this);
    }

    private void OnMessageReceived(object? sender, MessageReceivedEventArgs e)
    {
    }

    ~Client()
    {
        Dispose();
    }
}

Answer 1

则使用工厂

如果您确实需要取消订阅， ，则需要处置要被调用。 （不要使用最终确定器，因为您没有不受管理的内存。）

确保您的客户被处置（如果您不能相信人们使用>），那么我建议您使用工厂。

这样做，您将能够在依赖项注入容器中注册工厂，当您的申请关闭时，将调用工厂的处置，因此您将能够在那里处置所有创建的客户。

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace MyApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var hostBuilder = CreateHostBuilder(args);
            using var host = hostBuilder.Build();
            host.Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args)
        {
            IHostBuilder hostBuilder = Host.CreateDefaultBuilder(args);
            hostBuilder = hostBuilder.ConfigureServices((services) =>
            {
                services.AddSingleton<ClientFactory>();
                services.AddHostedService<MyHostedService>();
            });
            return hostBuilder;
        }
    }


    internal class MyHostedService : BackgroundService
    {
        private readonly ClientFactory _clientFactory;
        private readonly IHostApplicationLifetime _hostApplicationLifetime;

        /// <summary>
        /// Constructor used by dependency injection.
        /// </summary>
        public MyHostedService(ClientFactory clientFactory, IHostApplicationLifetime hostApplicationLifetime)
        {
            _clientFactory = clientFactory;
            _hostApplicationLifetime = hostApplicationLifetime;
        }

        protected override Task ExecuteAsync(CancellationToken stoppingToken)
        {
            var client1 = _clientFactory.GetClient();
            // Oups I forgot to dispose my client

            // Self destruction
            Thread.Sleep(1000);
            _hostApplicationLifetime.StopApplication();
            return Task.CompletedTask;
        }
    }

    internal class ClientFactory : IDisposable
    {
        private List<Client> _clients = new List<Client>();

        public void Dispose()
        {
            foreach (var client in _clients)
            {
                client.Dispose();
            }
            _clients.Clear();
        }

        public Client GetClient()
        {
            var client = new Client();
            _clients.Add(client);
            return client;
        }
    }

    internal class Client : IDisposable
    {
        public void Dispose()
        {
            // Unsubscribe your event here
            // ...
            Console.WriteLine("Client has been disposed");
        }
    }
}