How can I design a type-safe, generic asynchronous queue for sequential external API calls in C#?

You can avoid having to cast or use Reflection by letting polymorphism do the work. In other words, define an abstract (or virtual) method on your common base class, such as ExecuteAsync, that each derived queue item implements. Then your processor only needs to call that method without worrying about the underlying generic type.

Below is one way to modify your design:

---

Define the abstract base class with an ExecuteAsync method

CSHARPCopied
public abstract class MyQueueItem
{
    // Each derived type will implement this to:
    // - call its function
    // - set the TaskCompletionSource appropriately
    public abstract Task ExecuteAsync();
}

---

Update the generic queue item to override ExecuteAsync

CSHARPCopied
public class MyQueueItem<T> : MyQueueItem
{
    private readonly Func<Task<T>> _func;
    private readonly TaskCompletionSource<T> _tcs = new();

    public MyQueueItem(Func<Task<T>> func)
    {
        _func = func;
    }

    public Task<T> Task => _tcs.Task;

    public override async Task ExecuteAsync()
    {
        try
        {
            T result = await _func();
            _tcs.SetResult(result);
        }
        catch (Exception ex)
        {
            _tcs.SetException(ex);
        }
    }
}

---

Keep your queue class as before (with the only change being the item type constraint)

CSHARPCopied
public class MyQueue // singleton
{
    readonly ConcurrentQueue<MyQueueItem> queue = new();

    public async Task<T> EnqueueAndWaitAsync<T>(Func<Task<T>> func)
    {
        var item = new MyQueueItem<T>(func);
        queue.Enqueue(item);
        return await item.Task;
    }

    public async Task<MyQueueItem> DequeueAsync()
    {
        while (true)
        {
            if (queue.TryDequeue(out var item))
            {
                return item;
            }
            await Task.Delay(100);
        }
    }
}

---

Finally, modify your queue processor to simply call ExecuteAsync

CSHARPCopied
public class MyQueueProcessor
{
    private readonly MyQueue _queue;

    public MyQueueProcessor(MyQueue queue)
    {
        _queue = queue;
    }

    public async Task DoWorkAsync()
    {
        while (true) // In production, consider API throttling etc.
        {
            var item = await _queue.DequeueAsync();
            await item.ExecuteAsync();
        }
    }
}

---

Explanation

1. Polymorphic Execution:
   By adding an abstract ExecuteAsync to MyQueueItem, every derived type (in this case, MyQueueItem) provides its own implementation of how to execute the function and set the corresponding result or exception, all without exposing the underlying generic type.

2. Processor Simplicity:
   The processor no longer needs to know which type of function it is dealing with. It simply invokes ExecuteAsync on the dequeued MyQueueItem.

3. Strong Typing & Clarity:
   With this design, your API service and queue remain strongly typed, and you're not forced to cast everything to object or use Reflection, maintaining type safety and clarity.

This approach leverages polymorphism and ensures that all queue items can be processed uniformly regardless of their return type.