一、异步编程基础概念
1.1 为什么要异步编程？
避免UI线程阻塞：保持界面响应
提高吞吐量：I/O密集型操作不阻塞线程
资源高效利用：更少的线程处理更多请求
1.2 同步 vs 异步示例
csharp
// 同步方法 - 会阻塞线程 public string DownloadString(string url) { using var client = new WebClient(); return client.DownloadString(url); // 阻塞直到完成 } // 异步方法 - 不会阻塞线程 public async Task<string> DownloadStringAsync(string url) { using var client = new HttpClient(); return await client.GetStringAsync(url); // 立即返回，后台执行 }二、async/await 基础语法
2.1 基本结构
csharp
public class AsyncBasics { // 1. async 修饰符 // 2. 返回类型：Task, Task<T>, ValueTask<T> 或 void(不推荐) // 3. 方法名通常以Async结尾 public async Task<int> GetDataAsync() { // 4. await 等待异步操作完成 var result = await SomeAsyncOperation(); return result; } private async Task<int> SomeAsyncOperation() { await Task.Delay(1000); // 模拟异步操作 return 42; } }2.2 三种返回类型
csharp
public class ReturnTypes { // 1. Task<T> - 有返回值 public async Task<string> GetNameAsync() { await Task.Delay(100); return "Alice"; } // 2. Task - 无返回值 public async Task LogAsync(string message) { await Task.Delay(100); Console.WriteLine(message); } // 3. ValueTask<T> - 轻量级，适用于可能同步完成的操作 public async ValueTask<int> CalculateAsync(bool useCache) { if (useCache && cachedResult != null) return cachedResult.Value; // 同步返回 return await ComputeAsync(); // 异步计算 } }三、Task 深入理解
3.1 Task 状态机
csharp
public class TaskStates { public async Task DemonstrateTaskStates() { var task1 = Task.CompletedTask; // 已完成 var task2 = Task.Delay(1000); // 运行中 var task3 = Task.FromException(new Exception("Error")); // 出错 var task4 = Task.FromCanceled(new CancellationToken(true)); // 取消 // 检查状态 Console.WriteLine($"task1状态: {task1.Status}"); // RanToCompletion Console.WriteLine($"task2状态: {task2.Status}"); // WaitingForActivation } }3.2 Task 创建方式
csharp
public class TaskCreation { // 1. Task.Run - 线程池执行 public async Task UsingTaskRun() { // CPU密集型操作 var result = await Task.Run(() => { // 在后台线程执行 Thread.Sleep(1000); return ComplexCalculation(); }); } // 2. Task.Factory.StartNew - 更高级的控制 public async Task UsingTaskFactory() { var task = Task.Factory.StartNew( () => "Hello", CancellationToken.None, TaskCreationOptions.LongRunning, // 长时间运行任务 TaskScheduler.Default); } // 3. 直接返回已完成任务 public Task<string> GetCachedData() { if (cache.TryGetValue("key", out var data)) return Task.FromResult(data); // 无需async/await return FetchDataAsync(); } }四、异常处理
4.1 异步异常捕获
csharp
public class AsyncExceptionHandling { public async Task HandleExceptionsAsync() { try { await DangerousOperationAsync(); } catch (HttpRequestException ex) { // 处理网络异常 Console.WriteLine($"网络错误: {ex.Message}"); } catch (OperationCanceledException) { // 处理取消异常 Console.WriteLine("操作被取消"); } catch (AggregateException ex) { // 处理多个异常（Task.WhenAll可能抛出） foreach (var innerEx in ex.InnerExceptions) { Console.WriteLine($"内部异常: {innerEx.Message}"); } } } private async Task DangerousOperationAsync() { await Task.Delay(100); throw new HttpRequestException("模拟网络错误"); } }4.2 多个任务异常处理
csharp
public class MultipleTaskExceptionHandling { public async Task HandleMultipleTasksAsync() { var task1 = Task.Run(() => throw new Exception("任务1失败")); var task2 = Task.Run(() => throw new Exception("任务2失败")); // 方法1：分别处理 try { await task1; } catch { /* 处理任务1异常 */ } try { await task2; } catch { /* 处理任务2异常 */ } // 方法2：使用WhenAll并捕获AggregateException var allTasks = Task.WhenAll(task1, task2); try { await allTasks; } catch { // 检查每个任务的异常 if (allTasks.Exception != null) { foreach (var ex in allTasks.Exception.InnerExceptions) { Console.WriteLine(ex.Message); } } } } }五、取消操作
5.1 CancellationToken 使用
csharp
public class CancellationDemo { public async Task DownloadWithCancellationAsync( CancellationToken cancellationToken = default) { try { using var client = new HttpClient(); // 传递取消令牌 var response = await client.GetAsync( "https://api.example.com/data", cancellationToken); // 检查是否已取消 cancellationToken.ThrowIfCancellationRequested(); var content = await response.Content.ReadAsStringAsync(); } catch (OperationCanceledException) { Console.WriteLine("下载被取消"); // 清理资源 } } public async Task ProcessWithTimeoutAsync() { // 创建超时取消令牌 using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5)); try { await LongRunningOperationAsync(cts.Token); } catch (OperationCanceledException) { Console.WriteLine("操作超时"); } } // 支持取消的操作 public async Task LongRunningOperationAsync(CancellationToken cancellationToken) { for (int i = 0; i < 100; i++) { // 定期检查是否取消 cancellationToken.ThrowIfCancellationRequested(); // 模拟工作 await Task.Delay(100, cancellationToken); Console.WriteLine($"进度: {i}%"); } } }六、高级模式
6.1 ConfigureAwait
csharp
public class ConfigureAwaitDemo { // UI应用中使用ConfigureAwait(false)避免死锁 public async Task<string> GetDataWithoutContextAsync() { // 在库代码中使用ConfigureAwait(false)提高性能 using var client = new HttpClient(); var response = await client.GetAsync("https://api.example.com") .ConfigureAwait(false); // 不在原始上下文恢复 return await response.Content.ReadAsStringAsync() .ConfigureAwait(false); } // UI线程中需要更新界面 public async Task UpdateUIAsync() { var data = await GetDataWithoutContextAsync(); // 需要返回UI上下文更新界面 await Dispatcher.InvokeAsync(() => { textBox.Text = data; }); } }6.2 ValueTask 优化
csharp
public class ValueTaskOptimization { private string cachedResult; private DateTime cacheTime; // 使用ValueTask优化频繁调用的异步方法 public async ValueTask<string> GetDataOptimizedAsync() { // 检查缓存 if (cachedResult != null && DateTime.UtcNow - cacheTime < TimeSpan.FromMinutes(5)) { return cachedResult; // 同步返回，不分配Task } // 异步获取 cachedResult = await FetchFromNetworkAsync(); cacheTime = DateTime.UtcNow; return cachedResult; } }6.3 IAsyncEnumerable（C# 8.0+）
csharp
public class AsyncStreams { // 异步流 - 逐项异步生成数据 public async IAsyncEnumerable<int> GenerateSequenceAsync() { for (int i = 0; i < 10; i++) { await Task.Delay(100); // 模拟异步操作 yield return i; } } public async Task ConsumeAsyncStreamAsync() { // 使用await foreach消费异步流 await foreach (var number in GenerateSequenceAsync()) { Console.WriteLine(number); } // 带取消令牌 var cts = new CancellationTokenSource(); await foreach (var item in GenerateSequenceAsync() .WithCancellation(cts.Token)) { // 处理每个项目 } } }七、并行与并发
7.1 Task.WhenAll 和 Task.WhenAny
csharp
public class ParallelAsync { public async Task WhenAllDemoAsync() { var urls = new[] { "url1", "url2", "url3" }; // 并行执行多个异步操作 var downloadTasks = urls.Select(url => DownloadAsync(url)); var results = await Task.WhenAll(downloadTasks); // 所有结果都完成了 foreach (var result in results) { Process(result); } } public async Task WhenAnyDemoAsync() { var tasks = new[] { DownloadFromSource1Async(), DownloadFromSource2Async(), DownloadFromSource3Async() }; // 等待任意一个完成 var firstFinishedTask = await Task.WhenAny(tasks); var result = await firstFinishedTask; // 取消其他任务 foreach (var task in tasks) { if (!task.IsCompleted) { // 尝试取消或忽略 } } } // 限制并发数 public async Task ProcessWithConcurrencyLimitAsync() { var tasks = Enumerable.Range(1, 100) .Select(i => ProcessItemAsync(i)); // 使用SemaphoreSlim限制并发数 var semaphore = new SemaphoreSlim(5); // 最多5个并发 var limitedTasks = tasks.Select(async task => { await semaphore.WaitAsync(); try { return await task; } finally { semaphore.Release(); } }); var results = await Task.WhenAll(limitedTasks); } }八、异步模式与最佳实践
8.1 异步初始化模式
csharp
public class AsyncLazy<T> { private readonly Lazy<Task<T>> instance; public AsyncLazy(Func<Task<T>> factory) { instance = new Lazy<Task<T>>(factory); } public Task<T> Value => instance.Value; } // 使用示例 public class DataService { private readonly AsyncLazy<DatabaseConnection> connection = new AsyncLazy<DatabaseConnection>(async () => { var conn = new DatabaseConnection(); await conn.InitializeAsync(); return conn; }); public async Task ProcessDataAsync() { var conn = await connection.Value; // 只初始化一次 // 使用连接 } }8.2 异步锁
csharp
public class AsyncLock { private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1); public async Task<IDisposable> LockAsync() { await semaphore.WaitAsync(); return new Releaser(semaphore); } private class Releaser : IDisposable { private readonly SemaphoreSlim semaphore; public Releaser(SemaphoreSlim semaphore) => this.semaphore = semaphore; public void Dispose() => semaphore.Release(); } } // 使用示例 public class ResourceManager { private readonly AsyncLock asyncLock = new AsyncLock(); public async Task UpdateResourceAsync() { using (await asyncLock.LockAsync()) { // 临界区代码 await CriticalOperationAsync(); } } }九、性能注意事项
9.1 避免常见陷阱
csharp
public class PerformancePitfalls { // 错误：同步阻塞异步代码 public string GetDataBad() { return GetDataAsync().Result; // 可能导致死锁 } // 正确 public async Task<string> GetDataGood() { return await GetDataAsync(); } // 错误：async void（仅用于事件处理） public async void BadMethod() { await Task.Delay(100); // 异常无法捕获，调用者不知道何时完成 } // 正确 public async Task GoodMethod() { await Task.Delay(100); } // 避免过度异步化 public async Task<string> UnnecessaryAsync() { // 这个不需要异步 var data = GetFromCache(); return await Task.FromResult(data); // 多余 } // 正确：同步完成时直接返回 public Task<string> BetterMethod() { if (TryGetCached(out var data)) return Task.FromResult(data); return GetFromNetworkAsync(); } }十、调试与诊断
10.1 异步调用堆栈
csharp
public class AsyncDebugging { public async Task ComplexAsyncOperation() { try { await Step1Async(); } catch (Exception ex) { // 使用ex.ToString()获取完整异步堆栈 Console.WriteLine(ex.ToString()); } } // 使用async/await状态机标签 public async Task Step1Async() { await Task.Delay(100); await Step2Async(); } } // 使用Visual Studio的并行堆栈窗口 // 使用System.Diagnostics.Activity跟踪异步流10.2 异步日志记录
csharp
public class AsyncLogger { public async Task LogWithContextAsync() { // 记录异步操作上下文 var operationId = Guid.NewGuid(); using (LogContext.PushProperty("OperationId", operationId)) { await PerformOperationAsync(); } } }总结
关键要点：
理解async/await状态机：编译器将async方法转换为状态机
合理使用ConfigureAwait：库代码使用false，UI代码根据需要选择
正确处理异常和取消：避免未观察到的异常和资源泄漏
避免阻塞异步代码：不要使用.Result或.Wait()
考虑使用ValueTask：对于可能同步完成的高频调用
利用异步流：处理大量异步数据
注意线程上下文：了解执行在哪个线程上恢复
最佳实践：
异步方法名以Async结尾
避免async void（除了事件处理程序）
在库代码中始终使用ConfigureAwait(false)
及时处理取消请求
考虑并发限制，避免资源耗尽
使用合适的异步模式（如异步初始化、异步锁）
通过深入理解这些概念，你可以编写出高效、可维护且健壮的异步C#代码。
补充详解
一、异步编程的底层原理
1.1 状态机实现原理
csharp
// 编译器将async方法转换为状态机 public class AsyncStateMachineDemo { // 原始async方法 public async Task<int> ComputeAsync() { var result1 = await Step1Async(); var result2 = await Step2Async(result1); return result1 + result2; } // 编译器转换后的伪代码 [StructLayout(LayoutKind.Auto)] private struct ComputeAsyncStateMachine : IAsyncStateMachine { public int _state; public AsyncTaskMethodBuilder<int> _builder; public ComputeAsyncStateMachine _this; private TaskAwaiter<int> _awaiter1; private TaskAwaiter<int> _awaiter2; private int _result1; void IAsyncStateMachine.MoveNext() { int result; try { if (_state == 0) { // 状态0：开始执行Step1Async _awaiter1 = Step1Async().GetAwaiter(); if (!_awaiter1.IsCompleted) { _state = 1; _builder.AwaitUnsafeOnCompleted(ref _awaiter1, ref this); return; } } else if (_state == 1) { // 状态1：Step1Async完成，继续执行 } // ... 其他状态 } catch (Exception ex) { _builder.SetException(ex); return; } _builder.SetResult(result); } } }1.2 GetAwaiter和Awaiter模式
csharp
public class CustomAwaitable { // 实现可等待模式 public class CustomTaskAwaiter<TResult> : INotifyCompletion { private readonly Task<TResult> _task; private Action _continuation; public bool IsCompleted => _task.IsCompleted; public CustomTaskAwaiter(Task<TResult> task) => _task = task; public TResult GetResult() => _task.GetAwaiter().GetResult(); public void OnCompleted(Action continuation) { _continuation = continuation; _task.ContinueWith(_ => continuation()); } } public class CustomAwaitable<T> { private readonly Task<T> _task; public CustomAwaitable(Task<T> task) => _task = task; public CustomTaskAwaiter<T> GetAwaiter() => new CustomTaskAwaiter<T>(_task); } }二、高级异步模式
2.1 异步缓存模式
csharp
public class AsyncCache<TKey, TValue> { private readonly ConcurrentDictionary<TKey, Lazy<Task<TValue>>> _cache; private readonly Func<TKey, Task<TValue>> _valueFactory; public AsyncCache(Func<TKey, Task<TValue>> valueFactory) { _valueFactory = valueFactory; _cache = new ConcurrentDictionary<TKey, Lazy<Task<TValue>>>(); } public Task<TValue> GetAsync(TKey key) { return _cache.GetOrAdd(key, k => new Lazy<Task<TValue>>(() => _valueFactory(k), true) ).Value; } // 带过期时间的缓存 public class AsyncCacheWithExpiration<TKey, TValue> { private readonly ConcurrentDictionary<TKey, CacheItem> _cache; private readonly TimeSpan _expiration; private class CacheItem { public Task<TValue> Task { get; set; } public DateTime ExpiresAt { get; set; } public bool IsExpired => DateTime.UtcNow >= ExpiresAt; } public async Task<TValue> GetOrAddAsync(TKey key, Func<TKey, Task<TValue>> factory) { if (_cache.TryGetValue(key, out var item) && !item.IsExpired) return await item.Task; var newItem = new CacheItem { Task = factory(key), ExpiresAt = DateTime.UtcNow.Add(_expiration) }; _cache[key] = newItem; return await newItem.Task; } } }2.2 异步批处理模式
csharp
public class AsyncBatchProcessor<T> { private readonly int _batchSize; private readonly TimeSpan _batchTimeout; private readonly Func<List<T>, Task> _processBatch; private readonly object _lock = new object(); private List<T> _currentBatch; private Timer _timeoutTimer; public AsyncBatchProcessor( int batchSize, TimeSpan batchTimeout, Func<List<T>, Task> processBatch) { _batchSize = batchSize; _batchTimeout = batchTimeout; _processBatch = processBatch; _currentBatch = new List<T>(batchSize); } public async Task AddAsync(T item) { Task processTask = null; lock (_lock) { _currentBatch.Add(item); // 重置或启动超时计时器 _timeoutTimer?.Dispose(); _timeoutTimer = new Timer( _ => ProcessBatchAsync(), null, _batchTimeout, Timeout.InfiniteTimeSpan); // 检查是否达到批量大小 if (_currentBatch.Count >= _batchSize) { processTask = ProcessBatchAsync(); _timeoutTimer?.Dispose(); _timeoutTimer = null; } } if (processTask != null) await processTask; } private async Task ProcessBatchAsync() { List<T> batchToProcess; lock (_lock) { batchToProcess = _currentBatch; _currentBatch = new List<T>(_batchSize); _timeoutTimer?.Dispose(); _timeoutTimer = null; } if (batchToProcess.Count > 0) await _processBatch(batchToProcess); } }2.3 异步调度器
csharp
public class AsyncTaskScheduler : TaskScheduler { private readonly ConcurrentQueue<Task> _taskQueue = new(); private readonly SemaphoreSlim _semaphore; private readonly CancellationTokenSource _cts = new(); private int _activeTasks; public AsyncTaskScheduler(int maxDegreeOfParallelism) { _semaphore = new SemaphoreSlim(maxDegreeOfParallelism); } protected override void QueueTask(Task task) { _taskQueue.Enqueue(task); ProcessQueue(); } private async void ProcessQueue() { while (!_cts.Token.IsCancellationRequested && _taskQueue.TryDequeue(out var task)) { await _semaphore.WaitAsync(_cts.Token); Interlocked.Increment(ref _activeTasks); _ = Task.Run(async () => { try { TryExecuteTask(task); } finally { Interlocked.Decrement(ref _activeTasks); _semaphore.Release(); ProcessQueue(); // 处理下一个任务 } }, _cts.Token); } } protected override bool TryExecuteTaskInline( Task task, bool taskWasPreviouslyQueued) { // 内联执行策略 return false; // 或根据条件决定 } protected override IEnumerable<Task> GetScheduledTasks() { return _taskQueue.ToArray(); } }三、异步与并发集合
3.1 异步生产者消费者队列
csharp
public class AsyncProducerConsumerQueue<T> : IAsyncEnumerable<T> { private readonly Queue<T> _queue = new(); private readonly SemaphoreSlim _itemsAvailable = new(0); private readonly SemaphoreSlim _spaceAvailable; private readonly object _lock = new(); private bool _completed; public AsyncProducerConsumerQueue(int maxCapacity) { _spaceAvailable = new SemaphoreSlim(maxCapacity); } public async Task EnqueueAsync(T item, CancellationToken ct = default) { await _spaceAvailable.WaitAsync(ct); lock (_lock) { if (_completed) throw new InvalidOperationException("队列已关闭"); _queue.Enqueue(item); } _itemsAvailable.Release(); } public async Task<T> DequeueAsync(CancellationToken ct = default) { await _itemsAvailable.WaitAsync(ct); T item; lock (_lock) { if (_queue.Count == 0 && _completed) throw new InvalidOperationException("队列已关闭且为空"); item = _queue.Dequeue(); } _spaceAvailable.Release(); return item; } public void Complete() { lock (_lock) { _completed = true; _itemsAvailable.Release(int.MaxValue); // 唤醒所有等待者 } } public async IAsyncEnumerator<T> GetAsyncEnumerator( CancellationToken cancellationToken = default) { while (true) { try { yield return await DequeueAsync(cancellationToken); } catch (InvalidOperationException) when (_completed) { break; } } } }3.2 异步限流队列
csharp
public class ThrottledAsyncQueue<T> { private readonly Channel<T> _channel; private readonly TimeSpan _interval; private readonly int _maxItemsPerInterval; public ThrottledAsyncQueue( TimeSpan interval, int maxItemsPerInterval) { _interval = interval; _maxItemsPerInterval = maxItemsPerInterval; _channel = Channel.CreateUnbounded<T>( new UnboundedChannelOptions { SingleWriter = false, SingleReader = true }); } public async Task ProcessAsync( Func<T, Task> processor, CancellationToken ct = default) { var reader = _channel.Reader; var semaphore = new SemaphoreSlim(_maxItemsPerInterval); var resetTimer = new Timer(_ => semaphore.Release(_maxItemsPerInterval)); resetTimer.Change(_interval, _interval); try { await foreach (var item in reader.ReadAllAsync(ct)) { await semaphore.WaitAsync(ct); _ = ProcessItemAsync(item, processor); } } finally { resetTimer.Dispose(); } } private async Task ProcessItemAsync( T item, Func<T, Task> processor) { try { await processor(item); } catch { // 记录日志，但不重新抛出以避免中断整个流程 } } public ValueTask EnqueueAsync(T item, CancellationToken ct = default) { return _channel.Writer.WriteAsync(item, ct); } }四、异步性能优化
4.1 避免不必要的async/await
csharp
public class AsyncPerformanceOptimizations { // 情况1：简单传递任务 public Task<string> GetDataAsync() { return FetchDataAsync(); // 直接返回Task，不需要async/await } // 情况2：同步完成时 public Task<int> GetCachedValueAsync(int key) { if (_cache.TryGetValue(key, out var value)) return Task.FromResult(value); // 避免状态机分配 return GetFromSourceAsync(key); } // 情况3：使用ValueTask避免分配 public async ValueTask<DateTime> GetCurrentTimeAsync(bool useUtc) { if (useUtc) return DateTime.UtcNow; // 同步路径 await Task.Yield(); // 异步路径 return DateTime.Now; } }4.2 使用Pipelines进行高性能I/O
csharp
public class AsyncPipelineExample { public async Task ProcessFileWithPipelineAsync(string filePath) { await using var fileStream = File.OpenRead(filePath); var pipe = new Pipe(); // 写入任务 var writing = FillPipeAsync(fileStream, pipe.Writer); // 读取和处理任务 var reading = ReadPipeAsync(pipe.Reader); await Task.WhenAll(writing, reading); } private async Task FillPipeAsync(Stream stream, PipeWriter writer) { const int minimumBufferSize = 512; while (true) { var memory = writer.GetMemory(minimumBufferSize); int bytesRead = await stream.ReadAsync(memory); if (bytesRead == 0) break; writer.Advance(bytesRead); var result = await writer.FlushAsync(); if (result.IsCompleted) break; } await writer.CompleteAsync(); } private async Task ReadPipeAsync(PipeReader reader) { while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; // 处理数据 await ProcessBufferAsync(buffer); reader.AdvanceTo(buffer.End); if (result.IsCompleted) break; } await reader.CompleteAsync(); } }4.3 异步对象池
csharp
public class AsyncObjectPool<T> where T : class { private readonly ConcurrentQueue<T> _pool = new(); private readonly Func<Task<T>> _factory; private readonly Action<T> _reset; private readonly SemaphoreSlim _semaphore; private int _createdCount; private readonly int _maxSize; public AsyncObjectPool( int maxSize, Func<Task<T>> factory, Action<T> reset = null) { _maxSize = maxSize; _factory = factory; _reset = reset; _semaphore = new SemaphoreSlim(maxSize); } public async Task<PooledObject<T>> RentAsync(CancellationToken ct = default) { await _semaphore.WaitAsync(ct); if (_pool.TryDequeue(out var item)) { _reset?.Invoke(item); return new PooledObject<T>(item, Return); } if (Interlocked.Increment(ref _createdCount) <= _maxSize) { item = await _factory(); return new PooledObject<T>(item, Return); } Interlocked.Decrement(ref _createdCount); _semaphore.Release(); throw new InvalidOperationException("对象池已满"); } private void Return(T item) { _pool.Enqueue(item); _semaphore.Release(); } } public readonly struct PooledObject<T> : IDisposable where T : class { private readonly T _value; private readonly Action<T> _returnAction; public T Value => _value ?? throw new ObjectDisposedException(nameof(PooledObject<T>)); public PooledObject(T value, Action<T> returnAction) { _value = value; _returnAction = returnAction; } public void Dispose() { _returnAction?.Invoke(_value); } }五、异步异常高级处理
5.1 异常筛选器
csharp
public class AsyncExceptionFilters { public async Task ProcessWithExceptionFilterAsync() { try { await DangerousOperationAsync(); } // 使用异常筛选器 catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound) { // 只处理404错误 await HandleNotFoundAsync(); } catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.TooManyRequests) { // 处理速率限制 await HandleRateLimitAsync(ex); } catch (Exception ex) when (LogException(ex)) // 筛选器可以调用方法 { // 如果LogException返回true，会进入这里 throw; } } private bool LogException(Exception ex) { Console.WriteLine($"记录异常: {ex.Message}"); return true; } }5.2 聚合异常解包
csharp
public class AggregateExceptionUnwrapping { public async Task HandleMultipleExceptionsGracefullyAsync() { var tasks = new List<Task> { Task.Run(() => throw new InvalidOperationException("错误1")), Task.Run(() => throw new ArgumentException("错误2")), Task.Run(() => Task.CompletedTask) }; try { await Task.WhenAll(tasks); } catch (Exception ex) { // 处理聚合异常中的第一个异常 var firstException = ex is AggregateException aggEx ? aggEx.InnerExceptions.FirstOrDefault() : ex; Console.WriteLine($"第一个错误: {firstException?.Message}"); // 或者处理所有异常 if (ex is AggregateException aggregate) { foreach (var innerEx in aggregate.Flatten().InnerExceptions) { Console.WriteLine($"错误: {innerEx.Message}"); } } } // 检查每个任务的状态 foreach (var task in tasks) { if (task.IsFaulted) { Console.WriteLine($"任务失败: {task.Exception?.Message}"); } } } }六、异步与依赖注入
6.1 异步工厂模式
csharp
public interface IAsyncFactory<T> { Task<T> CreateAsync(); } public class AsyncDatabaseConnectionFactory : IAsyncFactory<IDbConnection> { private readonly string _connectionString; public AsyncDatabaseConnectionFactory(string connectionString) { _connectionString = connectionString; } public async Task<IDbConnection> CreateAsync() { var connection = new SqlConnection(_connectionString); await connection.OpenAsync(); return connection; } } // 在DI容器中注册 services.AddSingleton<IAsyncFactory<IDbConnection>>( sp => new AsyncDatabaseConnectionFactory(connectionString));6.2 异步初始化组件
csharp
public interface IAsyncInitializable { Task InitializeAsync(CancellationToken ct = default); } public class DatabaseService : IAsyncInitializable { private IDbConnection _connection; public async Task InitializeAsync(CancellationToken ct = default) { _connection = await CreateConnectionAsync(ct); await SeedDataAsync(ct); } // 应用启动时初始化 public class StartupInitializer { private readonly IEnumerable<IAsyncInitializable> _services; public StartupInitializer(IEnumerable<IAsyncInitializable> services) { _services = services; } public async Task InitializeAllAsync(CancellationToken ct = default) { var tasks = _services.Select(s => s.InitializeAsync(ct)); await Task.WhenAll(tasks); } } }七、异步调试技巧
7.1 可视化异步调用
csharp
public class AsyncDebuggingHelpers { [DebuggerStepThrough] public static async Task<T> WithDebugInfo<T>( Task<T> task, string operationName) { Console.WriteLine($"开始异步操作: {operationName}"); var sw = Stopwatch.StartNew(); try { var result = await task; Console.WriteLine($"完成异步操作 {operationName}, 耗时: {sw.Elapsed}"); return result; } catch (Exception ex) { Console.WriteLine($"异步操作 {operationName} 失败: {ex.Message}"); throw; } } // 使用Caller信息自动获取操作名 public static async Task<T> TraceAsync<T>( Task<T> task, [CallerMemberName] string caller = "", [CallerFilePath] string file = "", [CallerLineNumber] int line = 0) { var operation = $"{caller} at {Path.GetFileName(file)}:{line}"; return await WithDebugInfo(task, operation); } }7.2 异步死锁检测
csharp
public class AsyncDeadlockDetector { private readonly ConcurrentDictionary<int, DeadlockInfo> _activeOperations = new(); private readonly Timer _detectionTimer; private class DeadlockInfo { public string Operation { get; set; } public DateTime StartedAt { get; set; } public StackTrace CreationStackTrace { get; set; } } public AsyncDeadlockDetector() { _detectionTimer = new Timer(CheckForDeadlocks, null, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30)); } public IDisposable BeginOperation(string operationName) { var id = Task.CurrentId ?? Environment.CurrentManagedThreadId; var info = new DeadlockInfo { Operation = operationName, StartedAt = DateTime.UtcNow, CreationStackTrace = new StackTrace(true) }; _activeOperations[id] = info; return new DisposableAction(() => _activeOperations.TryRemove(id, out _)); } private void CheckForDeadlocks(object state) { var now = DateTime.UtcNow; var timeout = TimeSpan.FromMinutes(5); foreach (var kvp in _activeOperations) { if (now - kvp.Value.StartedAt > timeout) { Console.WriteLine($"检测到可能死锁: {kvp.Value.Operation}"); Console.WriteLine($"创建堆栈: {kvp.Value.CreationStackTrace}"); // 触发断点或记录到监控系统 Debugger.Break(); } } } }八、跨平台异步注意事项
8.1 平台特定的异步行为
csharp
public class PlatformAwareAsync { #if WINDOWS // Windows特定的异步优化 public async Task WindowsSpecificAsync() { // 使用Windows特有的API await Task.CompletedTask; } #elif LINUX // Linux特定的异步处理 public async Task LinuxSpecificAsync() { // Linux特定的文件I/O优化 await Task.Delay(1); } #endif // 通用的平台检测 public async Task PlatformAwareOperationAsync() { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { await WindowsOptimizedAsync(); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { await LinuxOptimizedAsync(); } } }8.2 异步与线程文化
csharp
public class CultureAwareAsync { // 保持异步操作中的文化上下文 public static async Task WithCultureContextAsync(Func<Task> operation) { var originalCulture = Thread.CurrentThread.CurrentCulture; var originalUICulture = Thread.CurrentThread.CurrentUICulture; try { await operation(); } finally { Thread.CurrentThread.CurrentCulture = originalCulture; Thread.CurrentThread.CurrentUICulture = originalUICulture; } } // 使用ExecutionContext保持上下文流动 public static async Task<T> WithExecutionContextAsync<T>(Func<Task<T>> operation) { var executionContext = ExecutionContext.Capture(); return await Task.Run(async () => { ExecutionContext.Restore(executionContext); return await operation(); }); } }九、未来发展趋势
9.1 .NET 7+ 异步改进
csharp
public class DotNet7AsyncFeatures { // 1. 静态接口方法中的异步支持 public interface IAsyncProcessor<T> { static abstract Task<T> ProcessAsync(T input); } // 2. 更高效的时间API public async Task ModernTimerAsync() { using var timer = new PeriodicTimer(TimeSpan.FromSeconds(1)); while (await timer.WaitForNextTickAsync()) { // 定时执行任务 await ProcessTickAsync(); } } // 3. 改进的ValueTask public async ValueTask<int> OptimizedValueTaskAsync() { await Task.Yield(); return 42; } }9.2 异步与Source Generators
csharp
// 使用Source Generators生成高性能异步代码 [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] public async ValueTask<int> GeneratedAsyncMethod() { await Task.Delay(100); return 42; } // 自定义AsyncMethodBuilder减少分配 public class PoolingAsyncValueTaskMethodBuilder<TResult> { // 实现自定义状态机池化 }十、实用工具类汇总
10.1 异步工具类
csharp
public static class AsyncHelpers { // 异步重试 public static async Task<T> RetryAsync<T>( Func<Task<T>> operation, int maxRetries, Func<Exception, TimeSpan> delayProvider) { for (int retry = 0; retry < maxRetries; retry++) { try { return await operation(); } catch (Exception ex) when (retry < maxRetries - 1) { var delay = delayProvider(ex); await Task.Delay(delay); } } return await operation(); // 最后一次尝试 } // 异步超时 public static async Task<T> WithTimeoutAsync<T>( Task<T> task, TimeSpan timeout) { using var cts = new CancellationTokenSource(timeout); var timeoutTask = Task.Delay(timeout, cts.Token); var completedTask = await Task.WhenAny(task, timeoutTask); if (completedTask == timeoutTask) throw new TimeoutException(); cts.Cancel(); // 取消延迟任务 return await task; } // 异步延迟队列 public static async Task DelayAsync( TimeSpan delay, CancellationToken ct = default) { if (delay <= TimeSpan.Zero) return; var tcs = new TaskCompletionSource<bool>(); using var timer = new Timer(_ => tcs.TrySetResult(true)); timer.Change(delay, Timeout.InfiniteTimeSpan); using var registration = ct.Register(() => tcs.TrySetCanceled()); await tcs.Task; } }总结补充
关键补充点：
深入理解状态机：async/await本质是编译器生成的复杂状态机
自定义Awaitable：可以实现自己的可等待类型
高级模式应用：批处理、缓存、调度等复杂场景
性能极致优化：避免分配、使用ValueTask、对象池
异常处理进阶：异常筛选器、聚合异常解包
并发集合集成：与Channel、管道等新API结合
跨平台兼容性：不同平台的异步行为差异
调试诊断工具：可视化、死锁检测等实用工具
依赖注入集成：异步工厂、异步初始化模式
未来发展趋势：.NET新版本异步改进
