OsdpConnectionListener.cs

using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
 
namespace OSDP.Net.Connections;

public abstract class OsdpConnectionListener : IOsdpConnectionListener
{
    private bool _disposedValue;
    private readonly ConcurrentDictionary<Task, OsdpConnection> _connections = new();

    protected OsdpConnectionListener(int baudRate, ILoggerFactory loggerFactory = null)
    {
        LoggerFactory = loggerFactory;
        Logger = loggerFactory?.CreateLogger<OsdpConnectionListener>();
        BaudRate = baudRate;
    }

    public bool IsRunning { get; protected set; }

    public int ConnectionCount => _connections.Count;

    protected ILoggerFactory LoggerFactory { get; }

    protected ILogger Logger { get; }

    public int BaudRate { get; }

    public abstract Task Start(Func<IOsdpConnection, Task> newConnectionHandler);

    public virtual async Task Stop()
    {
        IsRunning = false;
 
        Logger?.LogDebug("Stopping OSDP connection listener...");
 
        while (true)
        {
            var entries = _connections.ToArray();
            if (entries.Length == 0) break;
 
            await Task.WhenAll(entries.Select(item => item.Value.Close()));
            await Task.WhenAll(entries.Select(x => x.Key));
        }
 
        Logger?.LogDebug("OSDP connection listener stopped");
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected void RegisterConnection(OsdpConnection connection, Task task)
    {
        Task.Run(async () =>
        {
            _connections.TryAdd(task, connection);
            if (!IsRunning) await connection.Close();
            Logger?.LogDebug("New OSDP connection opened - total connections: {ConnectionCount}", _connections.Count);
            await task;
            _connections.TryRemove(task, out _);
            Logger?.LogDebug("OSDP connection terminated - remaining connections: {ConnectionCount}", _connections.Count);
        });
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposedValue)
        {
            if (disposing)
            {
                var _ = Stop();
            }
 
            _disposedValue = true;
        }
    }
}