using System;
using System.IO;
using System.Net.Http;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;


public static class AsyncBestPractices
{
    // 1. 使用內(nèi)置的異步API而非Task.Run
    public static async Task<string> DownloadFileAsync(string url)
    {
        using var client = new HttpClient();
        // 正確方式：使用內(nèi)置的異步方法
        return await client.GetStringAsync(url);


        // 錯誤方式：使用Task.Run包裝同步方法
        // return await Task.Run(() => client.GetString(url));
    }


    // 2. 文件操作的異步模式
    public static async Task ProcessFileAsync(string filePath)
    {
        // 讀取文件異步
        await using var fileStream = new FileStream(
            filePath, 
            FileMode.Open, 
            FileAccess.Read, 
            FileShare.Read,
            bufferSize: 4096, 
            useAsync: true); // 確保使用異步I/O


        using var reader = new StreamReader(fileStream);
        string content = await reader.ReadToEndAsync();


        // 處理內(nèi)容
        var processedContent = ProcessContent(content);


        // 寫回文件異步
        await using var outputStream = new FileStream(
            filePath + ".processed", 
            FileMode.Create, 
            FileAccess.Write, 
            FileShare.None,
            bufferSize: 4096, 
            useAsync: true);


        using var writer = new StreamWriter(outputStream);
        await writer.WriteAsync(processedContent);
    }


    private static string ProcessContent(string content)
    {
        // 模擬內(nèi)容處理
        return content.ToUpper();
    }


    // 3. 數(shù)據(jù)庫操作的異步模式 (Entity Framework Core)
    public static async Task<Order> GetOrderAsync(int orderId)
    {
        using var context = new OrderDbContext();
        // 使用EF Core的異步方法
        return await context.Orders.FindAsync(orderId);
    }


    // 4. 正確處理異步集合
    public static async Task ProcessOrdersAsync()
    {
        using var context = new OrderDbContext();


        // 流式處理大集合，避免一次性加載全部數(shù)據(jù)
        await foreach (var order in context.Orders.AsAsyncEnumerable())
        {
            await ProcessOrderAsync(order);
        }
    }


    private static async Task ProcessOrderAsync(Order order)
    {
        // 模擬異步處理訂單
        await Task.Delay(10); // 模擬IO操作
        Console.WriteLine($"處理訂單: {order.Id}");
    }


    // 5. 并行異步操作
    public static async Task DownloadMultipleFilesAsync(string[] urls)
    {
        // 創(chuàng)建所有下載任務(wù)
        var downloadTasks = urls.Select(url => DownloadAndSaveFileAsync(url));


        // 并行執(zhí)行所有任務(wù)
        await Task.WhenAll(downloadTasks);
    }


    private static async Task DownloadAndSaveFileAsync(string url)
    {
        using var client = new HttpClient();
        var content = await client.GetStringAsync(url);


        var fileName = Path.GetFileName(url);
        await File.WriteAllTextAsync(fileName, content);
    }


    // 6. 異步模式中的錯誤處理
    public static async Task SafeDownloadAsync(string url)
    {
        try
        {
            using var client = new HttpClient();
            var content = await client.GetStringAsync(url);
            await ProcessDownloadedContentAsync(content);
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"下載失敗: {ex.Message}");
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("操作已取消");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"發(fā)生未知錯誤: {ex.Message}");
        }
    }


    private static Task ProcessDownloadedContentAsync(string content)
    {
        // 處理下載內(nèi)容
        return Task.CompletedTask;
    }


    // 7. 異步模式中的CancellationToken使用
    public static async Task CancelableOperationAsync(CancellationToken cancellationToken)
    {
        using var client = new HttpClient();


        try
        {
            // 支持取消的異步操作
            var response = await client.GetAsync("https://example.com", cancellationToken);


            if (response.IsSuccessStatusCode)
            {
                var content = await response.Content.ReadAsStringAsync(cancellationToken);
                Console.WriteLine($"下載完成: {content.Length} 字符");
            }
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("操作被用戶取消");
        }
    }


    // 8. 避免在UI線程上阻塞
    // 假設(shè)這是在WPF/WinForms/UWP應(yīng)用中
    public static async void ButtonClickHandler(object sender, EventArgs e)
    {
        // 錯誤方式：在UI線程上等待任務(wù)完成
        // var result = LongRunningOperation().Result; // 會導(dǎo)致UI卡頓


        // 正確方式：使用await保持UI響應(yīng)性
        await LongRunningOperationAsync();
    }


    private static async Task LongRunningOperationAsync()
    {
        await Task.Delay(5000); // 模擬長時間運行的操作
        Console.WriteLine("操作完成");
    }


    // 9. 異步流處理 (IAsyncEnumerable)
    public static async IAsyncEnumerable<string> ReadLinesAsync(string filePath)
    {
        await using var fileStream = new FileStream(
            filePath, 
            FileMode.Open, 
            FileAccess.Read, 
            FileShare.Read,
            bufferSize: 4096, 
            useAsync: true);


        using var reader = new StreamReader(fileStream);


        string line;
        while ((line = await reader.ReadLineAsync()) != null)
        {
            yield return line;
        }
    }


    // 10. 異步模式中的SemaphoreSlim使用
    public static async Task ProcessItemsWithThrottleAsync(IEnumerable<string> items, int maxConcurrency = 5)
    {
        var semaphore = new SemaphoreSlim(maxConcurrency);


        var tasks = items.Select(async item =>
        {
            await semaphore.WaitAsync();


            try
            {
                await ProcessItemAsync(item);
            }
            finally
            {
                semaphore.Release();
            }
        });


        await Task.WhenAll(tasks);
    }


    private static async Task ProcessItemAsync(string item)
    {
        await Task.Delay(100); // 模擬處理時間
        Console.WriteLine($"處理項: {item}");
    }
}


// 簡單的EF Core上下文示例
public class OrderDbContext : DbContext
{
    public DbSet<Order> Orders { get; set; }


    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("YourConnectionString");
    }
}


public class Order
{
    public int Id { get; set; }
    public string CustomerName { get; set; }
    public DateTime OrderDate { get; set; }
}