using System;

using System.Collections.Concurrent;

using System.Threading;

using System.Threading.Tasks;

​

public class MockDatabaseConnection : IDisposable

{

    private static int _connectionId = 0;

    private int _id;

​

    public MockDatabaseConnection()

    {

        _id = Interlocked.Increment(ref _connectionId);

        Console.WriteLine($"Connection {_id} created.");

    }

​

    public void Dispose()

    {

        Console.WriteLine($"Connection {_id} disposed.");

    }

​

    public Task ExecuteQueryAsync(string query)

    {

        Console.WriteLine($"Connection {_id} executing query: {query}");

        return Task.Delay(100); // Simulate query execution time

    }

}

​

public class DatabaseConnectionPool

{

    private readonly SemaphoreSlim _semaphore;

    private readonly ConcurrentBag<MockDatabaseConnection> _connections;

    private readonly int _maxConnections;

    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();

    private int _idleConnections;

​

    public DatabaseConnectionPool(int maxConnections)

    {

        _maxConnections = maxConnections;

        _semaphore = new SemaphoreSlim(maxConnections);

        _connections = new ConcurrentBag<MockDatabaseConnection>();

    }

​

    public async Task<MockDatabaseConnection> GetConnectionAsync(int timeoutMilliseconds = 1000)

    {

        if (!await _semaphore.WaitAsync(timeoutMilliseconds))

        {

            throw new TimeoutException("Timeout waiting for connection.");

        }

​

        try

        {

            _lock.EnterReadLock();

            try

            {

                if (_connections.TryTake(out MockDatabaseConnection connection))

                {

                    Interlocked.Decrement(ref _idleConnections);

                    Console.WriteLine("Reusing existing connection.");

                    return connection;

                }

            }

            finally

            {

                _lock.ExitReadLock();

            }

​

            _lock.EnterWriteLock();

            try

            {

                Console.WriteLine("Creating new connection.");

                return new MockDatabaseConnection();

            }

            finally

            {

                _lock.ExitWriteLock();

            }

        }

        catch

        {

            _semaphore.Release();

            throw;

        }

    }

​

    public async Task ReturnConnectionAsync(MockDatabaseConnection connection)

    {

        _lock.EnterWriteLock();

        try

        {

            _connections.Add(connection);

            Interlocked.Increment(ref _idleConnections);

        }

        finally

        {

            _lock.ExitWriteLock();

        }

        _semaphore.Release();

    }

​

    public void LogConnectionStatus()

    {

        Console.WriteLine($"Active connections: {_maxConnections - _semaphore.CurrentCount}");

        Console.WriteLine($"Idle connections: {_idleConnections}");

    }

}

​

class Program

{

    static async Task Main(string[] args)

    {

        var connectionPool = new DatabaseConnectionPool(10);

​

        // Simulate high-demand scenario with multiple threads

        var tasks = new Task[100];

        for (int i = 0; i < 100; i++)

        {

            tasks[i] = Task.Run(async () =>

            {

                try

                {

                    var connection = await connectionPool.GetConnectionAsync();

                    await connection.ExecuteQueryAsync("SELECT * FROM table");

                    await connectionPool.ReturnConnectionAsync(connection);

                }

                catch (Exception ex)

                {

                    Console.WriteLine($"Error: {ex.Message}");

                }

            });

        }

​

        await Task.WhenAll(tasks);

​

        connectionPool.LogConnectionStatus();

    }

}