‫مدیریت لغو عملیات در برنامه‌نویسی ناهمگام با Task.FromCanceled

• public static Task FromCanceled(CancellationToken cancellationToken)
• public static Task<TResult> FromCanceled<TResult>(CancellationToken cancellationToken)

public async Task ProcessDataAsync(CancellationToken cancellationToken)
{
    if (cancellationToken.IsCancellationRequested)
    {
        return Task.FromCanceled(cancellationToken);
    }
    
    // ادامه با پردازش عادی
    return await DoWorkAsync();
}

public async Task<string> GetDataAsync(CancellationToken cancellationToken)
{
    if (cancellationToken.IsCancellationRequested)
    {
        return Task.FromCanceled<string>(cancellationToken);
    }
    
    return await FetchDataAsync();
}

public async Task<DataResult> ProcessLargeDatasetAsync(CancellationToken cancellationToken)
{
    if (cancellationToken.IsCancellationRequested)
    {
        return await Task.FromCanceled<DataResult>(cancellationToken);
    }

    var data = await LoadLargeDatasetAsync();
    return new DataResult(data);
}

public async Task<Report> GenerateReportAsync(ReportType type, CancellationToken cancellationToken)
{
    if (!IsReportTypeSupported(type))
    {
        return await Task.FromCanceled<Report>(cancellationToken);
    }

    return await GenerateReportInternalAsync(type);
}

public async Task<ValidationResult> ValidateDataAsync(DataModel data, CancellationToken cancellationToken)
{
    if (data == null)
    {
        return await Task.FromCanceled<ValidationResult>(cancellationToken);
    }

    return await PerformValidationAsync(data);
}

public async Task<Result> ProcessWithFallbackAsync(CancellationToken cancellationToken)
{
    try
    {
        return await PrimaryOperationAsync();
    }
    catch (OperationCanceledException)
    {
        return await Task.FromCanceled<Result>(cancellationToken);
    }
    catch (Exception)
    {
        return await FallbackOperationAsync();
    }
}

public class CustomTaskFactory
{
    public static async Task<T> CreateTaskAsync<T>(
        Func<Task<T>> operation,
        CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return await Task.FromCanceled<T>(cancellationToken);
        }
        try
        {
            return await operation();
        }
        catch (OperationCanceledException)
        {
            return await Task.FromCanceled<T>(cancellationToken);
        }
    }
}

public async Task<Result> ExecuteWithTimeoutAsync(
    Func<Task<Result>> operation,
    TimeSpan timeout)
{
    using var cts = new CancellationTokenSource(timeout);

    try
    {
        return await operation();
    }
    catch (OperationCanceledException)
    {
        return await Task.FromCanceled<Result>(cts.Token);
    }
}

• همیشه CancellationToken را ارسال کنید: همواره همان CancellationToken را که برای ایجاد تسک لغو شده استفاده شده است، به متد Task.FromCanceled ارسال کنید. ارسال یک CancellationToken جدید یا خالی، می‌تواند منجر به رفتار غیرمنتظره و عدم ردیابی صحیح لغو شود. این کار به سیستم لغو امکان می‌دهد که به درستی تشخیص دهد کدام عملیات لغو شده است.

// خوب
return Task.FromCanceled(cancellationToken);

// بد
return Task.FromCanceled(new CancellationToken());

• مدیریت graceful لغو: هنگام وقوع لغو، پیام‌های خطا یا لاگ‌های (Log) معنی‌دار ارائه دهید. این کار به اشکال‌زدایی (Debugging) و درک وضعیت برنامه در زمان لغو کمک می‌کند. لاگ‌کردن اطلاعات در مورد لغو، به تیم توسعه‌دهنده کمک می‌کند تا الگوهای لغو را شناسایی کرده و رفتار برنامه را در سناریوهای مختلف لغو بهبود بخشد.

public async Task<Result> ProcessWithMessageAsync(CancellationToken cancellationToken)
{
    if (cancellationToken.IsCancellationRequested)
    {
        _logger.LogInformation("Operation canceled by user");
        return await Task.FromCanceled<Result>(cancellationToken);
    }

    return await ProcessAsync();
}

• استفاده با Task.WhenAll: هنگام کار با چندین تسک به صورت همزمان (مثلاً با Task.WhenAll)، استفاده از Task.FromCanceled می‌تواند به شما کمک کند تا در صورت لغو یکی از تسک‌ها، کل مجموعه تسک‌ها را لغو شده اعلام کنید. این تضمین می‌کند که حتی اگر یک تسک لغو شود، Task.WhenAll نیز به درستی با یک OperationCanceledException تکمیل شود.

public async Task<Result[]> ProcessMultipleAsync(CancellationToken cancellationToken)
{
    var tasks = new List<Task<Result>>();

    foreach (var item in items)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return await Task.FromCanceled<Result[]>(cancellationToken);
        }

        tasks.Add(ProcessItemAsync(item));
    }

    return await Task.WhenAll(tasks);
}

public class DataProcessingPipeline
{
    private readonly ILogger<DataProcessingPipeline> _logger;
    
    public async Task<ProcessedData> ProcessDataAsync(
        RawData data,
        CancellationToken cancellationToken)
    {
        try
        {
            // اعتبارسنجی ورودی
            if (!IsValid(data))
            {
                _logger.LogWarning("Invalid data received");
                return await Task.FromCanceled<ProcessedData>(cancellationToken);
            }
            
            // پردازش داده
            var result = await TransformDataAsync(data);
            
            // اعتبارسنجی خروجی
            if (!IsValid(result))
            {
                _logger.LogError("Invalid result generated");
                return await Task.FromCanceled<ProcessedData>(cancellationToken);
            }
            
            return result;
        }
        catch (OperationCanceledException)
        {
            _logger.LogInformation("Operation canceled");
            return await Task.FromCanceled<ProcessedData>(cancellationToken);
        }
    }
}