C＃等待收藏

Question

Is there a standard way to await for a collection to be marked as complete by another task (thread?) I am looking for something like await collection.Completion.Task

So far I found the following approaches:

• Use a TaskCompletionSource variable (needs to be shared with the other task/thread)
• Use a BlockingCollection and do a while(!collection.IsAddingCompleted) {} (not async)
• Use a BufferBlock<T> from TPL Dataflow and do an await bufferBlock.Completion.Task (probably lots of overhead?)
• Use an ObservableCollection (not async)
• Any other?

All thoughts appreciated

EDIT: Adding scenario to give more context

class Program
{
    static void Main(string[] args)
    {
        var list = new List<int>();
        var tcs = new TaskCompletionSource<bool>();

        //This thread represents an independent process which will populate the list
        new Thread(() =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Thread.Sleep(200); // do work
                    list.Add(i);
                }
                tcs.SetResult(true);
                Thread.Sleep(2000); //do more work
                Console.WriteLine("The End -- Press Enter");
                Console.ReadLine();
            }
        ).Start();

        //This task awaits for the list to be populated
        new Task(async () =>
        {
            await Task.Delay(300); //do work
            await tcs.Task;
            Console.WriteLine("List count = " + list.Count);
        }).Start();
    }
}

Answer 1

Is there a standard way to await for a collection to be marked as complete by another task?

You can use any kind of "signal" for this. Since this is just a one-time signal, TaskCompletionSource<T> would be fine. The fact that it's a collection-completed signal is immaterial. Though, as you found, some collections do have this built-in.

To address each of your questions:

• TaskCompletionSource<T> - the most straightforward, IMO, since it can be used with any kind of collection.
• BlockingCollection<T> - You wouldn't want to use BlockingCollection , but you can use an AsyncProducerConsumerQueue or AsyncCollection , which are the same abstraction but allowing asynchronous waits.
• BufferBlock<T> - Also fine. A lot of people use BufferBlock<T> as an async-compatible producer/consumer queue.
• ObservableCollection<T> - not an option since it doesn't have the notion of "completion".
• Others - If your collection is "push-based", you can use IObservable<T> and just await it.