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

namespace ConsoleApp {
    public class ProgramTests {
        [Fact(DisplayName = "ProcessInBatchesAsync processes all tasks in the input list")]
        public async Task ProcessInBatchesAsync_ProcessesAllTasks()
        {
            ConcurrentBag<int> completed = new ConcurrentBag<int>();
            List<Func<Task>> tasks = new List<Func<Task>>();
            for (int i = 1; i <= 10; i++) {
                int capture = i;
                tasks.Add(async () => { await Task.Delay(5); completed.Add(capture); });
            }
            await BatchProcessor.ProcessInBatchesAsync(tasks, 3);
            var completedList = completed.ToList();
            completedList.Sort();
            Assert.Equal(Enumerable.Range(1, 10).ToList(), completedList);
        }

        [Fact(DisplayName = "ProcessInBatchesAsync does not start more than batchSize tasks concurrently")]
        public async Task ProcessInBatchesAsync_RespectsBatchSizeConcurrency()
        {
            object lockObj = new object();
            int maxConcurrent = 0;
            int currentConcurrent = 0;
            List<Func<Task>> tasks = new List<Func<Task>>();
            for (int i = 0; i < 8; i++) {
                tasks.Add(async () => {
                    lock (lockObj) { currentConcurrent++; if (currentConcurrent > maxConcurrent) maxConcurrent = currentConcurrent; }
                    await Task.Delay(40);
                    lock (lockObj) { currentConcurrent--; }
                });
            }
            await BatchProcessor.ProcessInBatchesAsync(tasks, 3);
            Assert.True(maxConcurrent <= 3, $"Expected at most 3 concurrent tasks per batch, but got {maxConcurrent}");
        }

        [Fact(DisplayName = "ProcessInBatchesAsync starts each batch only after previous batch completes")]
        public async Task ProcessInBatchesAsync_BatchesAreSequential()
        {
            List<int> started = new List<int>();
            List<int> finished = new List<int>();
            List<Func<Task>> tasks = new List<Func<Task>>();
            int batchSize = 2;
            int totalTasks = 6;
            for (int i = 0; i < totalTasks; i++) {
                int capture = i;
                tasks.Add(async () => {
                    started.Add(capture);
                    await Task.Delay(20);
                    finished.Add(capture);
                });
            }
            await BatchProcessor.ProcessInBatchesAsync(tasks, batchSize);
            // Check that tasks are started in order and not all at once
            Assert.True(started.Count == totalTasks, "All tasks should have started");
            List<List<int>> batchStarts = new List<List<int>>();
            for (int i = 0; i < totalTasks; i += batchSize) {
                batchStarts.Add(started.Skip(i).Take(batchSize).ToList());
            }
            // Ensure batches are sequential
            for (int i = 0; i < batchStarts.Count - 1; i++) {
                List<int> thisBatch = batchStarts[i];
                List<int> nextBatch = batchStarts[i + 1];
                // All tasks in this batch should finish before next batch starts
                int lastFinishedOfThisBatch = finished.IndexOf(thisBatch.Last());
                int firstStartedOfNextBatch = started.IndexOf(nextBatch.First());
                Assert.True(lastFinishedOfThisBatch < firstStartedOfNextBatch, $"Batch {i} did not finish before batch {i + 1} started");
            }
        }
    }
}

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: Batch Processing with Async

解答