C# async/await完全ガイド：パフォーマンスを最大化する7つの実装テクニック

はじめに

C#のasync/awaitは非同期プログラミングを簡潔に実装できる強力な機能ですが、適切な使用方法を理解していないと、パフォーマンスの低下やメモリリークなどの問題を引き起こす可能性があります。
本記事では、async/awaitの基礎から実践的な実装テクニック、そしてパフォーマンス最適化まで、体系的に解説します。

async/awaitとは：非同期プログラミングの基礎知識

同期処理と非同期処理の違いを理解する

同期処理と非同期処理の違いは、タスクの実行方法とプログラムの制御フローにあります。以下で具体的に説明していきます。

以下のコード例で、同期処理と非同期処理の違いを見てみましょう。

// 同期処理の例
public string DownloadDataSync(string url)
{
    // この処理が完了するまで、プログラムはここでブロックされる
    using (var client = new WebClient())
    {
        return client.DownloadString(url);
    }
}

// 非同期処理の例
public async Task<string> DownloadDataAsync(string url)
{
    // 非同期でダウンロードを実行し、完了を待機
    // この間、他の処理を実行可能
    using (var client = new HttpClient())
    {
        return await client.GetStringAsync(url);
    }
}

なぜC#でasync/awaitが必要なのか

async/awaitが必要となる主な理由は以下の通りです。

以下は、WebAPIでの実装例です。

// 非同期処理を活用したWebAPIコントローラーの例
public class ProductController : ApiController
{
    private readonly IProductRepository _repository;

    public ProductController(IProductRepository repository)
    {
        _repository = repository;
    }

    // 非同期メソッドの実装
    public async Task<IHttpActionResult> GetProductAsync(int id)
    {
        try
        {
            // データベースからの非同期読み取り
            var product = await _repository.GetProductByIdAsync(id);
            if (product == null)
            {
                return NotFound();
            }

            return Ok(product);
        }
        catch (Exception ex)
        {
            // エラーログの非同期記録
            await LogErrorAsync(ex);
            return InternalServerError();
        }
    }
}

このコードでは、データベースアクセスとエラーログの記録を非同期で行うことで、以下のメリットが得られます。

async/awaitを使用することで、これらの利点を簡潔なコードで実現できます。
次のセクションでは、async/awaitの具体的な実装方法について詳しく説明していきます。

async/awaitの基本的な実装方法

このセクションでは、async/awaitの基本的な実装方法について、実践的な例を交えて説明します。

asyncキーワードの正しい使い方

非同期プログラミングの基礎となるasyncキーワードの使用方法を説明します。

// 基本的な非同期メソッドの定義
public async Task ProcessDataAsync(Data data)
{
    // 非同期処理を実装
    await Task.Delay(100); // 例示用の遅延
    await ProcessInternalAsync(data);
}

// 値を返す非同期メソッド
public async Task<Result> GetResultAsync()
{
    var data = await FetchDataAsync();
    return new Result { Data = data };
}

// イベントハンドラーでの使用
// 注意: async voidは通常避けるべきだが、イベントハンドラーは例外
private async void Button_Click(object sender, EventArgs e)
{
    try
    {
        await ProcessDataAsync(new Data());
    }
    catch (Exception ex)
    {
        // エラーハンドリング
        MessageBox.Show(ex.Message);
    }
}

awaitキーワードによる非同期処理の制御

await式の正しい使用方法と、効率的な非同期処理の制御について説明します。

public class AsyncOperationController
{
    // 複数の非同期操作の制御
    public async Task ProcessMultipleOperationsAsync()
    {
        // 順次実行が必要な場合
        var result1 = await Operation1Async();
        var result2 = await Operation2Async(result1);

        // 並列実行が可能な場合
        var task1 = Operation3Async();
        var task2 = Operation4Async();
        await Task.WhenAll(task1, task2);

        // タイムアウト付きの実行
        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
        try
        {
            await TimeoutSensitiveOperationAsync(cts.Token);
        }
        catch (OperationCanceledException)
        {
            // タイムアウト処理
        }
    }

    // 進捗報告付きの非同期処理
    public async Task ProcessWithProgressAsync(IProgress<int> progress)
    {
        for (int i = 0; i < 100; i += 10)
        {
            await Task.Delay(100); // 進捗のシミュレート
            progress?.Report(i);
        }
    }
}

戻り値の型（Task, Task<T>, ValueTask）の使い分け

各戻り値型の特徴と適切な使用場面について説明します。

public class ReturnTypeExamples
{
    private readonly Dictionary<string, int> _cache = new();

    // Task: 値を返さない非同期処理
    public async Task UpdateDataAsync()
    {
        await Task.Delay(100);
        // データ更新処理
    }

    // Task<T>: 値を返す標準的な非同期処理
    public async Task<int> CalculateAsync(int input)
    {
        await Task.Delay(100);
        return input * 2;
    }

    // ValueTask: キャッシュヒット時に割り当てを削減
    public ValueTask<int> GetValueAsync(string key)
    {
        // キャッシュヒット時は同期的に返却
        if (_cache.TryGetValue(key, out int value))
        {
            return new ValueTask<int>(value);
        }

        // キャッシュミス時は非同期に取得
        return new ValueTask<int>(LoadValueAsync(key));
    }

    // ValueTaskの高度な使用例
    private readonly ValueTask<int> _completedTask = 
        new ValueTask<int>(42);

    public ValueTask<int> GetCachedValueAsync()
    {
        return _completedTask; // 事前に作成したValueTaskを再利用
    }

    private async Task<int> LoadValueAsync(string key)
    {
        await Task.Delay(100); // 外部リソースからの取得をシミュレート
        var value = await ComputeValueAsync(key);
        _cache[key] = value;
        return value;
    }
}

戻り値型の選択基準

これらの基本的な実装パターンを理解することで、効率的な非同期プログラミングの基礎が築けます。
次のセクションでは、これらの基本を踏まえた上で、パフォーマンスを最大化するための具体的なテクニックについて説明します。

パフォーマンスを最大化する7つのテクニック

1: ConfigureAwaitの適切な使用

ConfigureAwait(false)の効果的な使用方法とパフォーマンスへの影響を説明します。

public class ConfigureAwaitOptimization
{
    // ライブラリコードでの実装例
    public async Task<Data> GetDataAsync()
    {
        // UIコンテキストが不要な処理
        var rawData = await FetchDataAsync()
            .ConfigureAwait(false);

        var processed = await ProcessDataAsync(rawData)
            .ConfigureAwait(false);

        return processed;
    }

    // UI更新を含む処理
    public async Task UpdateUIAsync(Data data)
    {
        // UI更新が必要な処理はConfigureAwait(false)を使用しない
        await Task.Delay(100); // UI更新をシミュレート
        await DisplayDataAsync(data); // UIスレッドが必要
    }
}

2: 並列処理によるパフォーマンス向上

より詳細な並列処理の制御方法を示します。

public class ParallelProcessingOptimization
{
    private readonly SemaphoreSlim _semaphore;
    private readonly ILogger<ParallelProcessingOptimization> _logger;

    public ParallelProcessingOptimization(ILogger<ParallelProcessingOptimization> logger)
    {
        // プロセッサ数に基づいて並列度を設定
        _semaphore = new SemaphoreSlim(Environment.ProcessorCount);
        _logger = logger;
    }

    // 並列度制御付きの処理
    public async Task ProcessItemsWithControlledParallelismAsync(
        IEnumerable<Item> items,
        CancellationToken cancellationToken)
    {
        var tasks = new List<Task>();

        foreach (var item in items)
        {
            // キャンセル要求のチェック
            cancellationToken.ThrowIfCancellationRequested();

            // 並列度を制御しながらタスクを作成
            tasks.Add(ProcessWithSemaphoreAsync(item, cancellationToken));
        }

        try
        {
            await Task.WhenAll(tasks).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Parallel processing failed");
            throw;
        }
    }

    private async Task ProcessWithSemaphoreAsync(
        Item item,
        CancellationToken cancellationToken)
    {
        try
        {
            await _semaphore.WaitAsync(cancellationToken)
                .ConfigureAwait(false);

            await ProcessItemAsync(item, cancellationToken)
                .ConfigureAwait(false);
        }
        finally
        {
            _semaphore.Release();
        }
    }

    // バッチ処理の最適化
    public async Task ProcessInBatchesAsync(
        IEnumerable<Item> items,
        int batchSize = 100)
    {
        var batches = items.Chunk(batchSize);

        foreach (var batch in batches)
        {
            var batchTasks = batch.Select(ProcessItemAsync);
            await Task.WhenAll(batchTasks).ConfigureAwait(false);
        }
    }
}

3: キャンセレーショントークンの実装

より堅牢なキャンセル処理の実装方法を示します。

public class CancellationHandling
{
    private readonly ILogger<CancellationHandling> _logger;

    public async Task ProcessWithTimeoutAsync(
        Func<CancellationToken, Task> operation,
        TimeSpan timeout)
    {
        using var cts = new CancellationTokenSource();
        using var linkedCts = CancellationTokenSource
            .CreateLinkedTokenSource(cts.Token);

        // タイムアウトの設定
        linkedCts.CancelAfter(timeout);

        try
        {
            var timeoutTask = Task.Delay(timeout, linkedCts.Token);
            var operationTask = operation(linkedCts.Token);

            var completedTask = await Task.WhenAny(
                operationTask, timeoutTask)
                .ConfigureAwait(false);

            if (completedTask == timeoutTask)
            {
                throw new TimeoutException(
                    $"Operation timed out after {timeout.TotalSeconds} seconds");
            }

            await operationTask.ConfigureAwait(false);
        }
        catch (OperationCanceledException) when (linkedCts.Token.IsCancellationRequested)
        {
            _logger.LogWarning("Operation was cancelled");
            throw;
        }
        finally
        {
            // キャンセルトークンのクリーンアップ
            linkedCts.Cancel();
        }
    }
}

4: 例外処理の最適化

パフォーマンスを考慮した例外処理の実装方法を示します。

public class OptimizedExceptionHandling
{
    private readonly ILogger<OptimizedExceptionHandling> _logger;
    private readonly CircuitBreaker _circuitBreaker = new();

    public async Task<Result> ExecuteWithRetryAsync(
        Func<CancellationToken, Task<Result>> operation,
        int maxRetries = 3,
        CancellationToken cancellationToken = default)
    {
        // サーキットブレーカーチェック
        if (!_circuitBreaker.CanExecute())
        {
            throw new CircuitBreakerOpenException();
        }

        for (int i = 0; i <= maxRetries; i++)
        {
            try
            {
                return await operation(cancellationToken)
                    .ConfigureAwait(false);
            }
            catch (Exception ex) when (ShouldRetry(ex) && i < maxRetries)
            {
                _logger.LogWarning(ex, 
                    "Retry attempt {Attempt} of {MaxRetries}",
                    i + 1, maxRetries);

                // 指数バックオフ
                await Task.Delay(
                    TimeSpan.FromSeconds(Math.Pow(2, i)),
                    cancellationToken).ConfigureAwait(false);
            }
        }

        _circuitBreaker.RecordFailure();
        throw new MaxRetriesExceededException();
    }
}

5: メモリ使用量の削減テクニック

public class MemoryOptimizedOperations
{
    private readonly ArrayPool<byte> _arrayPool = 
        ArrayPool<byte>.Shared;
    private readonly MemoryPool<char> _memoryPool = 
        MemoryPool<char>.Shared;

    public async Task ProcessLargeDataAsync(
        Stream inputStream,
        Stream outputStream,
        CancellationToken cancellationToken)
    {
        byte[] buffer = _arrayPool.Rent(81920); // 80KB
        try
        {
            int bytesRead;
            while ((bytesRead = await inputStream
                .ReadAsync(buffer, cancellationToken)
                .ConfigureAwait(false)) > 0)
            {
                await outputStream
                    .WriteAsync(buffer.AsMemory(0, bytesRead), cancellationToken)
                    .ConfigureAwait(false);
            }
        }
        finally
        {
            _arrayPool.Return(buffer);
        }
    }

    // StringBuilderプールの実装
    private readonly ObjectPool<StringBuilder> _builderPool =
        new DefaultObjectPool<StringBuilder>(
            new StringBuilderPooledObjectPolicy());

    public async Task<string> BuildLargeStringAsync(
        IAsyncEnumerable<string> parts)
    {
        var builder = _builderPool.Get();
        try
        {
            await foreach (var part in parts)
            {
                builder.Append(part);
            }
            return builder.ToString();
        }
        finally
        {
            builder.Clear();
            _builderPool.Return(builder);
        }
    }
}

6: デッドロックを防ぐための設計パターン

public class DeadlockPreventionPatterns
{
    // 非同期ファクトリーメソッド
    public static async Task<DeadlockPreventionPatterns> CreateAsync()
    {
        var instance = new DeadlockPreventionPatterns();
        await instance.InitializeAsync().ConfigureAwait(false);
        return instance;
    }

    // 非同期初期化
    private async Task InitializeAsync()
    {
        await Task.Yield(); // 同期コンテキストからの解放
        // 初期化処理
    }

    // 非同期破棄パターン
    public async ValueTask DisposeAsync()
    {
        await CleanupAsync().ConfigureAwait(false);
        GC.SuppressFinalize(this);
    }
}

7: ValueTaskの効果的な活用

public class ValueTaskOptimization
{
    private readonly IMemoryCache _cache;

    // 完了済みのValueTaskのキャッシュ
    private static readonly ValueTask<int> DefaultValueTask = 
        new ValueTask<int>(42);

    public ValueTask<int> GetOptimizedValueAsync(string key)
    {
        // キャッシュヒット時は割り当てなしで返却
        if (_cache.TryGetValue<int>(key, out var value))
        {
            return DefaultValueTask;
        }

        // キャッシュミス時のみTaskを作成
        return new ValueTask<int>(LoadValueAsync(key));
    }

    // ValueTaskの使用に関する注意点
    public async ValueTask<Result> ProcessDataAsync(Data data)
    {
        // ValueTaskは一度だけawaitする
        var result = await GetOptimizedValueAsync("key")
            .ConfigureAwait(false);

        // 結果を返却
        return new Result { Value = result };
    }
}

これらの最適化テクニックを適切に組み合わせることで、非同期処理のパフォーマンスを大幅に向上させることができます。
次のセクションでは、これらのテクニックを実際のユースケースに適用する方法を説明します。

実践的なユースケースと実装例

WebAPIでの非同期処理の実装

マイクロサービスアーキテクチャにおける効率的なWeb APIの実装例を示します。

public class OrderController : ControllerBase
{
    private readonly IOrderService _orderService;
    private readonly IBackgroundJobScheduler _jobScheduler;
    private readonly ILogger<OrderController> _logger;
    private readonly IMetricsCollector _metrics;

    public class CreateOrderRequest
    {
        public string CustomerId { get; set; }
        public List<OrderItem> Items { get; set; }
        public PaymentInfo PaymentInfo { get; set; }
    }

    [HttpPost("orders")]
    public async Task<IActionResult> CreateOrderAsync(
        CreateOrderRequest request,
        CancellationToken cancellationToken)
    {
        using var scope = _logger.BeginScope(
            "Creating order for customer {CustomerId}", 
            request.CustomerId);

        try
        {
            // 並列バリデーション
            var validationTasks = new[]
            {
                ValidateInventoryAsync(request.Items, cancellationToken),
                ValidateCustomerAsync(request.CustomerId, cancellationToken),
                ValidatePaymentAsync(request.PaymentInfo, cancellationToken)
            };

            if (!await Task.WhenAll(validationTasks)
                .ContinueWith(t => t.Result.All(r => r), 
                    cancellationToken)
                .ConfigureAwait(false))
            {
                return BadRequest("Validation failed");
            }

            // 注文処理
            var order = await _orderService
                .CreateOrderAsync(request, cancellationToken)
                .ConfigureAwait(false);

            // バックグラウンドジョブのスケジューリング
            await _jobScheduler
                .ScheduleAsync(new ProcessOrderJob(order.Id))
                .ConfigureAwait(false);

            // メトリクスの記録
            _metrics.RecordOrderCreation(order.TotalAmount);

            return CreatedAtAction(
                nameof(GetOrderAsync),
                new { id = order.Id },
                order);
        }
        catch (Exception ex) when (ex is not OperationCanceledException)
        {
            _logger.LogError(ex, "Failed to create order");
            return StatusCode(500, "Internal server error");
        }
    }

    [HttpGet("orders/{id}")]
    public async Task<IActionResult> GetOrderAsync(
        string id,
        CancellationToken cancellationToken)
    {
        try
        {
            var order = await _orderService
                .GetOrderAsync(id, cancellationToken)
                .ConfigureAwait(false);

            if (order == null)
            {
                return NotFound();
            }

            return Ok(order);
        }
        catch (Exception ex) when (ex is not OperationCanceledException)
        {
            _logger.LogError(ex, "Failed to get order {OrderId}", id);
            return StatusCode(500, "Internal server error");
        }
    }
}

データベースアクセスの非同期化

Entity Frameworkを使用した効率的なデータアクセスパターンの実装例を示します。

public class OrderRepository : IOrderRepository
{
    private readonly AppDbContext _context;
    private readonly IMemoryCache _cache;
    private readonly ILogger<OrderRepository> _logger;
    private readonly SemaphoreSlim _semaphore = new(1);

    public async Task<Order> GetByIdWithCachingAsync(
        string id,
        CancellationToken cancellationToken)
    {
        var cacheKey = $"order_{id}";

        try
        {
            // キャッシュチェック
            if (_cache.TryGetValue<Order>(cacheKey, out var cachedOrder))
            {
                _logger.LogDebug("Cache hit for order {OrderId}", id);
                return cachedOrder;
            }

            // 複数リクエストによるキャッシュ更新の重複を防ぐ
            await _semaphore.WaitAsync(cancellationToken)
                .ConfigureAwait(false);

            // 二重チェック
            if (_cache.TryGetValue<Order>(cacheKey, out cachedOrder))
            {
                return cachedOrder;
            }

            // データベースからの取得
            var order = await _context.Orders
                .Include(o => o.Items)
                .Include(o => o.Customer)
                .AsNoTracking()
                .FirstOrDefaultAsync(o => o.Id == id, cancellationToken)
                .ConfigureAwait(false);

            if (order != null)
            {
                var cacheOptions = new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(TimeSpan.FromMinutes(10))
                    .RegisterPostEvictionCallback((key, value, reason, state) =>
                    {
                        _logger.LogDebug(
                            "Order {OrderId} evicted from cache. Reason: {Reason}",
                            id, reason);
                    });

                _cache.Set(cacheKey, order, cacheOptions);
            }

            return order;
        }
        finally
        {
            _semaphore.Release();
        }
    }

    public async Task<IReadOnlyList<Order>> GetRecentOrdersAsync(
        string customerId,
        int count,
        CancellationToken cancellationToken)
    {
        // 効率的なクエリ実行
        return await _context.Orders
            .Where(o => o.CustomerId == customerId)
            .OrderByDescending(o => o.CreatedAt)
            .Take(count)
            .Select(o => new Order
            {
                Id = o.Id,
                CustomerId = o.CustomerId,
                TotalAmount = o.TotalAmount,
                Status = o.Status,
                CreatedAt = o.CreatedAt
            })
            .AsNoTracking()
            .ToListAsync(cancellationToken)
            .ConfigureAwait(false);
    }
}

ファイル操作での活用方法

大容量ファイルの効率的な処理と進捗報告の実装例を示します。

public class FileProcessor
{
    private readonly ILogger<FileProcessor> _logger;
    private readonly ArrayPool<byte> _arrayPool;

    public async Task ProcessLargeFileAsync(
        string inputPath,
        string outputPath,
        IProgress<int> progress,
        CancellationToken cancellationToken)
    {
        var fileInfo = new FileInfo(inputPath);
        var totalBytes = fileInfo.Length;
        var processedBytes = 0L;

        // 最適なバッファサイズの使用
        var buffer = _arrayPool.Rent(81920); // 80KB

        try
        {
            await using var input = new FileStream(
                inputPath,
                FileMode.Open,
                FileAccess.Read,
                FileShare.Read,
                bufferSize: 4096,
                useAsync: true);

            await using var output = new FileStream(
                outputPath,
                FileMode.Create,
                FileAccess.Write,
                FileShare.None,
                bufferSize: 4096,
                useAsync: true);

            int bytesRead;
            while ((bytesRead = await input
                .ReadAsync(buffer, cancellationToken)
                .ConfigureAwait(false)) > 0)
            {
                await output
                    .WriteAsync(buffer.AsMemory(0, bytesRead), cancellationToken)
                    .ConfigureAwait(false);

                processedBytes += bytesRead;
                var percentComplete = (int)((processedBytes * 100) / totalBytes);
                progress?.Report(percentComplete);

                // リソース解放のための定期的なGC要求
                if (processedBytes % (10 * 1024 * 1024) == 0) // 10MB毎
                {
                    GC.Collect(0, GCCollectionMode.Optimized);
                }
            }
        }
        finally
        {
            _arrayPool.Return(buffer);
        }
    }

    // チャンク単位での並列処理
    public async Task ProcessFileInChunksAsync(
        string inputPath,
        int chunkSize,
        Func<byte[], int, Task> processChunk,
        CancellationToken cancellationToken)
    {
        var chunks = new ConcurrentQueue<(long Offset, int Size)>();
        var fileInfo = new FileInfo(inputPath);
        var totalChunks = (int)Math.Ceiling(fileInfo.Length / (double)chunkSize);

        // チャンク情報の生成
        for (long offset = 0; offset < fileInfo.Length; offset += chunkSize)
        {
            var size = (int)Math.Min(chunkSize, fileInfo.Length - offset);
            chunks.Enqueue((offset, size));
        }

        // 並列処理の制御
        var tasks = new List<Task>();
        var semaphore = new SemaphoreSlim(Environment.ProcessorCount);

        while (chunks.TryDequeue(out var chunk))
        {
            await semaphore.WaitAsync(cancellationToken)
                .ConfigureAwait(false);

            tasks.Add(Task.Run(async () =>
            {
                try
                {
                    using var fileStream = new FileStream(
                        inputPath,
                        FileMode.Open,
                        FileAccess.Read,
                        FileShare.Read);

                    fileStream.Seek(chunk.Offset, SeekOrigin.Begin);
                    var buffer = new byte[chunk.Size];
                    var bytesRead = await fileStream
                        .ReadAsync(buffer, cancellationToken)
                        .ConfigureAwait(false);

                    await processChunk(buffer, bytesRead)
                        .ConfigureAwait(false);
                }
                finally
                {
                    semaphore.Release();
                }
            }, cancellationToken));
        }

        await Task.WhenAll(tasks).ConfigureAwait(false);
    }
}

これらの実装例は、実際のプロジェクトで直面する一般的なシナリオに対する効率的な解決策を示しています。
次のセクションでは、これらの実装で注意すべきアンチパターンについて説明します。

async/awaitのアンチパターンと回避方法

非同期処理の連鎖による性能低下

非同期処理を不適切に連鎖させることによるパフォーマンスの低下とその解決策を説明します。

不必要な直列化と並列処理の活用

public class AsyncChainAntipatterns
{
    // アンチパターン: 不必要な直列化
    public async Task<List<Result>> ProcessItemsBadlyAsync(
        IEnumerable<Item> items)
    {
        var results = new List<Result>();
        foreach (var item in items) // 逐次処理
        {
            var result = await ProcessItemAsync(item); // 直列実行
            results.Add(result);
        }
        return results;
    }

    // 改善例: 並列処理の活用
    public async Task<List<Result>> ProcessItemsProperlyAsync(
        IEnumerable<Item> items)
    {
        // すべてのタスクを同時に開始
        var tasks = items.Select(item => ProcessItemAsync(item));
        var results = await Task.WhenAll(tasks).ConfigureAwait(false);
        return results.ToList();
    }
}

不必要なタスク生成と直接非同期メソッドを呼び出し

public class AsyncChainAntipatterns
{
    // アンチパターン: 不必要なタスク生成
    public async Task<Data> GetDataBadlyAsync()
    {
        return await Task.Run(async () =>
        {
            var result = await FetchDataAsync(); // 不要なTask.Run
            return result;
        });
    }

    // 改善例: 直接非同期メソッドを呼び出し
    public Task<Data> GetDataProperlyAsync()
    {
        return FetchDataAsync(); // 直接非同期メソッドを返す
    }
}

例外処理の誤った実装

非同期処理における不適切な例外処理とその改善方法を示します。

例外の握りつぶしと適切な例外処理

public class ExceptionHandlingAntipatterns
{
    // アンチパターン: 例外の握りつぶし
    public async Task ProcessDataBadlyAsync()
    {
        try
        {
            await RiskyOperationAsync();
        }
        catch (Exception)
        {
            // 何もしない - 危険！
        }
    }

    // 改善例: 適切な例外処理
    public async Task ProcessDataProperlyAsync()
    {
        try
        {
            await RiskyOperationAsync().ConfigureAwait(false);
        }
        catch (SpecificException ex)
        {
            // 特定の例外に対する適切な処理
            await HandleSpecificErrorAsync(ex).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            // ログ記録と上位層への通知
            _logger.LogError(ex, "Unexpected error occurred");
            throw;
        }
    }
}

例外の処置漏れと適切な例外処理

public class ExceptionHandlingAntipatterns
{
    // アンチパターン: async void
    public async void HandleEventBadly(object sender, EventArgs e)
    {
        await RiskyOperationAsync(); // 例外が失われる可能性
    }

    // 改善例: イベントハンドラでの適切な例外処理
    public async void HandleEventProperly(object sender, EventArgs e)
    {
        try
        {
            await RiskyOperationAsync().ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Event handler failed");
            // UIの場合はユーザーに通知
            await ShowErrorDialogAsync(ex.Message).ConfigureAwait(false);
        }
    }
}

不適切なコンテキスト切り替え

コンテキスト切り替えに関する問題とその解決策を示します。

不要なコンテキスト復帰と必要な場合のみコンテキスト復帰

public class ContextSwitchingAntipatterns
{
    // アンチパターン: 不要なコンテキスト復帰
    private async Task DoWorkBadlyAsync()
    {
        var data = await GetDataAsync(); // コンテキスト復帰が必要
        await ProcessDataAsync(data); // さらにコンテキスト復帰
    }

    // 改善例: 必要な場合のみコンテキスト復帰
    private async Task DoWorkProperlyAsync()
    {
        var data = await GetDataAsync().ConfigureAwait(false);
        await ProcessDataAsync(data).ConfigureAwait(false);
    }
}

デッドロックの危険性と同期呼び出しが必要な場合の対処

public class ContextSwitchingAntipatterns
{
    // アンチパターン: デッドロックの危険性
    public Result GetDataSynchronously()
    {
        return GetDataAsync().Result; // デッドロックの可能性
    }

    // 改善例: 同期呼び出しが必要な場合の対処
    public Result GetDataSynchronouslyProperly()
    {
        return Task.Run(async () =>
        {
            return await GetDataAsync().ConfigureAwait(false);
        }).GetAwaiter().GetResult();
    }
}

メモリリークの防止

非同期処理におけるメモリリークの防止方法を示します。

public class MemoryLeakPrevention : IAsyncDisposable
{
    private readonly CancellationTokenSource _cts = new();
    private readonly SemaphoreSlim _semaphore = new(1);
    private bool _disposed;

    // アンチパターン: リソースの解放忘れ
    public async Task ProcessDataBadlyAsync()
    {
        var semaphore = new SemaphoreSlim(1); // 解放されない
        await semaphore.WaitAsync();
        try
        {
            await DoWorkAsync();
        }
        finally
        {
            semaphore.Release();
        }
    }

    // 改善例: 適切なリソース管理
    public async Task ProcessDataProperlyAsync()
    {
        await _semaphore.WaitAsync().ConfigureAwait(false);
        try
        {
            await DoWorkAsync().ConfigureAwait(false);
        }
        finally
        {
            _semaphore.Release();
        }
    }

    // 非同期破棄の実装
    public async ValueTask DisposeAsync()
    {
        if (_disposed)
        {
            return;
        }

        _disposed = true;

        // キャンセルを要求
        _cts.Cancel();

        // 管理リソースの解放
        _cts.Dispose();
        _semaphore.Dispose();

        await CleanupAsync().ConfigureAwait(false);

        GC.SuppressFinalize(this);
    }

    // イベントハンドラの適切な解除
    private readonly List<WeakReference<IDisposable>> _eventHandlers = new();

    public void RegisterEventHandler(IDisposable handler)
    {
        _eventHandlers.Add(new WeakReference<IDisposable>(handler));
    }

    private async Task CleanupAsync()
    {
        foreach (var handlerRef in _eventHandlers)
        {
            if (handlerRef.TryGetTarget(out var handler))
            {
                handler.Dispose();
            }
        }
        _eventHandlers.Clear();
    }
}

リソース管理のアンチパターン

非同期処理におけるリソース管理の問題とその解決策を示します。

using句の不適切な使用

public class ResourceManagementAntipatterns
{
    // アンチパターン: using句の不適切な使用
    public async Task ProcessFileBadlyAsync(string path)
    {
        using var stream = new FileStream(path, FileMode.Open);
        await ProcessStreamAsync(stream); // streamが早期に解放される可能性
    }

    // 改善例: await usingの使用
    public async Task ProcessFileProperlyAsync(string path)
    {
        await using var stream = new FileStream(
            path,
            FileMode.Open,
            FileAccess.Read,
            FileShare.Read,
            bufferSize: 4096,
            useAsync: true);

        await ProcessStreamAsync(stream).ConfigureAwait(false);
    }
}

非同期破棄の考慮漏れ

public class ResourceManagementAntipatterns
{
    // アンチパターン: 非同期破棄の考慮漏れ
    public class BadResourceManager
    {
        private readonly HttpClient _client = new();

        public void Dispose() // 非同期破棄に対応していない
        {
            _client.Dispose();
        }
    }

    // 改善例: 非同期破棄の実装
    public class ProperResourceManager : IAsyncDisposable
    {
        private readonly HttpClient _client = new();
        private bool _disposed;

        public async ValueTask DisposeAsync()
        {
            if (_disposed)
            {
                return;
            }

            _disposed = true;

            // 管理リソースの解放
            _client.Dispose();

            // 非同期クリーンアップ
            await CleanupAsync().ConfigureAwait(false);

            GC.SuppressFinalize(this);
        }

        private async Task CleanupAsync()
        {
            // 非同期クリーンアップ処理
            await Task.CompletedTask.ConfigureAwait(false);
        }
    }
}

これらのアンチパターンを理解し、適切な実装パターンを採用することで、より信頼性の高い非同期プログラミングが実現できます。
次のセクションでは、これらの実装のパフォーマンスを測定し、最適化する方法について説明します。

パフォーマンス測定とチューニング手法

非同期処理のボトルネック特定方法

パフォーマンス測定と分析のための実装例を示します。

public class PerformanceMonitoring
{
    private readonly ILogger<PerformanceMonitoring> _logger;
    private readonly Metrics _metrics;

    // パフォーマンス測定デコレータ
    public async Task<T> MeasureExecutionAsync<T>(
        string operationName,
        Func<Task<T>> operation)
    {
        using var activity = Activity.Current?.Source
            .StartActivity($"Execute_{operationName}");

        var sw = Stopwatch.StartNew();
        try
        {
            var result = await operation().ConfigureAwait(false);

            // メトリクスの記録
            _metrics.RecordDuration(operationName, sw.Elapsed);

            activity?.SetTag("duration_ms", sw.ElapsedMilliseconds);
            activity?.SetTag("success", true);

            return result;
        }
        catch (Exception ex)
        {
            activity?.SetTag("error", ex.GetType().Name);
            activity?.SetTag("success", false);
            throw;
        }
        finally
        {
            sw.Stop();
            _logger.LogInformation(
                "{Operation} completed in {Duration}ms",
                operationName,
                sw.ElapsedMilliseconds);
        }
    }

    // メモリ使用量の監視
    public class MemoryMonitor : IDisposable
    {
        private readonly string _operationName;
        private readonly long _initialMemory;
        private readonly Stopwatch _sw;
        private readonly ILogger _logger;

        public MemoryMonitor(string operationName, ILogger logger)
        {
            _operationName = operationName;
            _logger = logger;
            _initialMemory = GC.GetTotalMemory(false);
            _sw = Stopwatch.StartNew();
        }

        public void Dispose()
        {
            _sw.Stop();
            var finalMemory = GC.GetTotalMemory(false);
            var memoryDiff = finalMemory - _initialMemory;

            _logger.LogInformation(
                "{Operation} used {MemoryMB:F2}MB over {Duration}ms",
                _operationName,
                memoryDiff / 1024.0 / 1024.0,
                _sw.ElapsedMilliseconds);
        }
    }
}

パフォーマンス改善のための計測と最適化

ベンチマークとプロファイリングの実装例を示します。

public class PerformanceOptimization
{
    // ベンチマーク定義
    [MemoryDiagnoser]
    public class AsyncOperationsBenchmark
    {
        private readonly SampleData[] _testData = GenerateTestData(1000);
        private readonly ParallelOptions _parallelOptions = new()
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount
        };

        [Benchmark(Baseline = true)]
        public async Task TraditionalAsync()
        {
            foreach (var item in _testData)
            {
                await ProcessItemAsync(item).ConfigureAwait(false);
            }
        }

        [Benchmark]
        public async Task ParallelForEachAsync()
        {
            await Parallel.ForEachAsync(_testData, _parallelOptions,
                async (item, token) =>
                {
                    await ProcessItemAsync(item).ConfigureAwait(false);
                });
        }

        [Benchmark]
        public async Task BatchProcessingAsync()
        {
            var batches = _testData.Chunk(100);
            foreach (var batch in batches)
            {
                var tasks = batch.Select(ProcessItemAsync);
                await Task.WhenAll(tasks).ConfigureAwait(false);
            }
        }
    }

    // パフォーマンス最適化例
    public class OptimizedDataProcessor
    {
        private readonly MemoryCache _cache;
        private readonly SemaphoreSlim _semaphore;
        private readonly Channel<WorkItem> _channel;

        public OptimizedDataProcessor()
        {
            _cache = new MemoryCache(new MemoryCacheOptions
            {
                SizeLimit = 1024
            });
            _semaphore = new SemaphoreSlim(Environment.ProcessorCount);
            _channel = Channel.CreateBounded<WorkItem>(new BoundedChannelOptions(100)
            {
                FullMode = BoundedChannelFullMode.Wait
            });
        }

        public async Task ProcessDataStreamAsync(
            IAsyncEnumerable<Data> dataStream,
            CancellationToken cancellationToken)
        {
            // 並列処理ワーカーの起動
            var processingTask = Task.Run(async () =>
            {
                await foreach (var item in _channel.Reader.ReadAllAsync(cancellationToken))
                {
                    await ProcessWorkItemAsync(item, cancellationToken)
                        .ConfigureAwait(false);
                }
            });

            // データストリームの処理
            await foreach (var data in dataStream.WithCancellation(cancellationToken))
            {
                var workItem = new WorkItem(data);
                await _channel.Writer.WriteAsync(workItem, cancellationToken)
                    .ConfigureAwait(false);
            }

            _channel.Writer.Complete();
            await processingTask.ConfigureAwait(false);
        }

        private async Task ProcessWorkItemAsync(
            WorkItem item,
            CancellationToken cancellationToken)
        {
            await _semaphore.WaitAsync(cancellationToken)
                .ConfigureAwait(false);
            try
            {
                // キャッシュチェック
                var cacheKey = item.GetCacheKey();
                if (_cache.TryGetValue(cacheKey, out var cachedResult))
                {
                    return;
                }

                // 処理の実行
                var result = await ProcessInternalAsync(item, cancellationToken)
                    .ConfigureAwait(false);

                // キャッシュの更新
                var cacheEntryOptions = new MemoryCacheEntryOptions()
                    .SetSize(1)
                    .SetSlidingExpiration(TimeSpan.FromMinutes(5));

                _cache.Set(cacheKey, result, cacheEntryOptions);
            }
            finally
            {
                _semaphore.Release();
            }
        }
    }
}

パフォーマンスチューニングのベストプラクティス

実践的なチューニング手法とその効果を示します。

public class PerformanceTuningExamples
{
    // 1. ValueTaskの効果的な使用
    private static readonly ValueTask<int> _cachedResult = 
        new ValueTask<int>(42);

    public ValueTask<int> GetOptimizedValueAsync(bool useCache)
    {
        return useCache ? _cachedResult : 
            new ValueTask<int>(LoadValueAsync());
    }

    // 2. バッファプールの活用
    private readonly ArrayPool<byte> _arrayPool = ArrayPool<byte>.Shared;

    public async Task ProcessDataStreamAsync(
        Stream stream,
        CancellationToken cancellationToken)
    {
        var buffer = _arrayPool.Rent(81920);
        try
        {
            await ProcessWithBufferAsync(stream, buffer, cancellationToken)
                .ConfigureAwait(false);
        }
        finally
        {
            _arrayPool.Return(buffer);
        }
    }

    // 3. 効率的な並列処理
    public async Task ProcessItemsAsync(
        IEnumerable<Item> items,
        CancellationToken cancellationToken)
    {
        var options = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount,
            CancellationToken = cancellationToken
        };

        await Parallel.ForEachAsync(items, options,
            async (item, token) =>
            {
                await ProcessItemAsync(item, token)
                    .ConfigureAwait(false);
            });
    }

    // 4. メモリ効率の最適化
    public async IAsyncEnumerable<Result> ProcessLargeDataSetAsync(
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        await foreach (var item in GetDataStreamAsync()
            .WithCancellation(cancellationToken))
        {
            var result = await ProcessItemAsync(item, cancellationToken)
                .ConfigureAwait(false);
            yield return result;
        }
    }
}

パフォーマンス測定結果の分析

パフォーマンス測定結果のサンプルと分析方法を示します。

ベンチマーク結果の例(BenchmarkDotNet=v0.13.5)

これらの測定とチューニング手法を適切に活用することで、非同期処理のパフォーマンスを最適化し、アプリケーションの応答性と効率性を向上させることができます。

パフォーマンスチューニングは継続的なプロセスであり、定期的な測定と分析、そして必要に応じた最適化が重要です。

async/awaitのまとめ

async/awaitを効果的に活用することで、アプリケーションの応答性と処理効率を大幅に向上させることができます。
本記事で解説した実装テクニックとパフォーマンス最適化手法を実践することで、スケーラブルで信頼性の高い非同期処理を実現できます。

これらのポイントを押さえることで、効率的で保守性の高い非同期プログラミングが実現できます。