using System;

using System.Linq;

using System.Threading;

using System.Threading.Tasks;

using System.Collections.Generic;

using System.Diagnostics;

​

// A very simple thread-safe string pool that..

//

//  1. Allow the first available item to borrowered using a blocking function with a cancellation token.

//  2. Allows a specific item to be borrowered with the same blocking behavior.

//  3. Allows items to be returned.

//

// Making this generic would make it more useful (e.g. ValueSelectableBlockingPool<T>) but we should only do

// that if we actually have more than 1 use case for this. It's amazing to me that something like this doesn't

// exist out-of-the-box in the dotnet ecosystem... but, doesn't seem to.

//

// And, before making this a truely generic pool, there are other things to address. Specifically a proper

// pool...

//   1. Doesn't allow values to be returned that weren't borrowed. That can be accomplished through a 

//      separate borrowedItems list, but... meh.

//   2. Allows items to be added / removed.

//

// Note: This is not a *concurrent* pool because no operations can actually be done

// concurrently. Concurrency requires requires copy-on-write and copy-on-read behavior that we don't need.

//

// 

public class ThreadSafeValuePool<T> {

   private readonly object lockObj;

   private readonly IList<T> internalList; // unfortunately, no suitable interface seems to exist.

   public ThreadSafeValuePool(params T[] values) : this(values.AsEnumerable<T>())

   {}

   public ThreadSafeValuePool(IEnumerable<T> values){

       lockObj = new ();

       internalList = new List<T>(values);

   }

​

   public T Borrow(CancellationToken token) {

       while(!token.IsCancellationRequested)

       {

            if (Monitor.TryEnter(lockObj, TimeSpan.FromMilliseconds(1)))

            {

                try{

                    if (internalList.Count() > 0)

                    {

                        var item = internalList[0];

                        internalList.RemoveAt(0);

                        return item;

                    }

                }

                finally{

                    Monitor.Exit(lockObj);

                }

            }

            token.WaitHandle.WaitOne(TimeSpan.FromMilliseconds(1));

       }

       throw new Exception();   

   }

    public T Borrow(Func<T, bool> selectorFn, CancellationToken token)

    {

       // check if the specific value is of the possible set here;

       while(!token.IsCancellationRequested)

       {

           if (Monitor.TryEnter(lockObj, TimeSpan.FromMilliseconds(1)))

           {

              try

              {

                  T targetValue = internalList.FirstOrDefault(v => selectorFn(v));

                  if(targetValue != null)

                  {                  

                     internalList.Remove(targetValue);

                     return targetValue;

                  }

              }

              finally

              {

                  Monitor.Exit(lockObj);

              }

           }

           token.WaitHandle.WaitOne(TimeSpan.FromMilliseconds(1));

       }

       throw new Exception();

    }

    public T Borrow(T specificValue, CancellationToken token) =>

        Borrow((T item) => specificValue.Equals(item), token);

    public void ReturnValue(T returnedValue, CancellationToken token)

    {

        while(!token.IsCancellationRequested)

        {

            if (Monitor.TryEnter(lockObj, TimeSpan.FromMilliseconds(1)))

            {

                try

                {

                    internalList.Add(returnedValue);

                    return;

                }

                finally

                {

                    Monitor.Exit(lockObj);

                }

            }

            token.WaitHandle.WaitOne(TimeSpan.FromMilliseconds(1));

        }

    }

}

​

public class Program

{

    public static void Main()

    {

        var threadSafePool = new ThreadSafeValuePool<string>("1", "2", "3", "4", "5");

        // Basic test to show that borrowing works.

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

        {

            var borroweredValue = threadSafePool.Borrow(CancellationToken.None);

            Console.WriteLine($"Value borrowered was {borroweredValue}");

        }

        // Show that borrow blocks, but can be cancelled by a token

        CancellationTokenSource manualCancellationToken = new CancellationTokenSource();

        manualCancellationToken.CancelAfter(100);

        var sw = new Stopwatch();

        sw.Start();

        // This will block for until the token cancels, then it will throw

        try

        {

            threadSafePool.Borrow(manualCancellationToken.Token);

        }

        catch(Exception)

        {

            sw.Stop();

            Console.WriteLine($"borrow blocked {sw.ElapsedMilliseconds}ms before cancellation");

        }

        // Show that borrow blocks until a value is available, then returns shortly thereafter.

        Task.Run(() => {

            Thread.Sleep(100);

            threadSafePool.ReturnValue("5", CancellationToken.None);

        });

        sw.Reset();

        sw.Start();

        string borrowedValue = threadSafePool.Borrow(CancellationToken.None);

        sw.Stop();

        Console.WriteLine($"Got a value of {borrowedValue} back after blocking for {sw.ElapsedMilliseconds}ms");

        // Show that borrow for a *specific value* blocks that value is available. Notice, the first value added

        // into the pool was *not* the value being searched for.

        Task.Run(() => {

            Thread.Sleep(100);

            threadSafePool.ReturnValue("5", CancellationToken.None);

            Thread.Sleep(100);

            threadSafePool.ReturnValue("3", CancellationToken.None);

        });

        sw.Reset();

        sw.Start();

        borrowedValue = threadSafePool.Borrow("3", CancellationToken.None);

        sw.Stop();

        Console.WriteLine($"Got the specified value of {borrowedValue} back after blocking for {sw.ElapsedMilliseconds}ms");

    }

}