
using Xunit;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp {
    public class ProgramTests {
        [Fact(DisplayName = "All task factories are started and completed")] 
        public async Task AllTasksAreStartedAndCompleted() 
        {
            var processor = new ParallelTaskProcessor();
            int started = 0;
            int completed = 0;
            var factories = new List<Func<Task>>();
            for (int i = 0; i < 5; i++) {
                factories.Add(async () => {
                    Interlocked.Increment(ref started);
                    await Task.Delay(50);
                    Interlocked.Increment(ref completed);
                });
            }
            await processor.ProcessTasksWithLimitAsync(factories, 2);
            Assert.Equal(5, started);
            Assert.Equal(5, completed);
        }

        [Fact(DisplayName = "No more than maxDegreeOfParallelism tasks run concurrently")] 
        public async Task NoMoreThanMaxParallelismRun() 
        {
            var processor = new ParallelTaskProcessor();
            int concurrent = 0;
            int maxObserved = 0;
            var factories = new List<Func<Task>>();
            for (int i = 0; i < 10; i++) {
                factories.Add(async () => {
                    int running = Interlocked.Increment(ref concurrent);
                    if (running > maxObserved)
                        maxObserved = running;
                    await Task.Delay(100);
                    Interlocked.Decrement(ref concurrent);
                });
            }
            int maxParallel = 4;
            await processor.ProcessTasksWithLimitAsync(factories, maxParallel);
            Assert.True(maxObserved <= maxParallel, $"Expected max concurrent tasks <= {maxParallel}, but got {maxObserved}");
        }

        [Fact(DisplayName = "Method waits for all tasks to complete before returning")] 
        public async Task WaitsForAllTasksToComplete() 
        {
            var processor = new ParallelTaskProcessor();
            bool[] completed = new bool[3];
            var factories = new List<Func<Task>>();
            for (int i = 0; i < 3; i++) {
                int idx = i;
                factories.Add(async () => {
                    await Task.Delay(30 + idx * 30);
                    completed[idx] = true;
                });
            }
            await processor.ProcessTasksWithLimitAsync(factories, 2);
            Assert.All(completed, x => Assert.True(x, "Not all tasks completed before return."));
        }
    }
}

ProgramTests.cs

Master asynchronous programming in C# with hands-on practice and engaging explanations. Learn to convert synchronous code to async, process collections concurrently, handle timeouts, and manage errors effectively using async/await.

Learn the basics of async/await in C# and how to convert synchronous code to asynchronous for better performance and responsiveness.

Explore how to use async/await in loops and process collections of data asynchronously for efficient, scalable code.

Master advanced async/await concepts: handling timeouts, managing sequential vs. parallel tasks, and robust error handling.

Challenge: Control Parallelism in Async Tasks

解答