‫مدیریت خطا در برنامه‌نویسی ناهمگام #C: درک Task.FromException

• public static Task FromException(Exception exception): برای تسک‌هایی که نتیجه‌ای باز نمی‌گردانند.
• public static Task<TResult> FromException<TResult>(Exception exception): برای تسک‌هایی که یک نتیجه از نوع TResult را باز می‌گردانند.

public async Task ProcessDataAsync()
{
    try
    {
        // عملیات ناهمگام
        await DoWorkAsync();
    }
    catch (Exception ex)
    {
        return Task.FromException(ex);
    }
}

public async Task<string> GetDataAsync()
{
    try
    {
        return await FetchDataAsync();
    }
    catch (Exception ex)
    {
        return Task.FromException<string>(ex);
    }
}

public async Task<ValidationResult> ValidateDataAsync(DataModel data)
{
    if (data == null)
    {
        return await Task.FromException<ValidationResult>(
            new ArgumentNullException(nameof(data)));
    }
    
    if (!IsValid(data))
    {
        return await Task.FromException<ValidationResult>(
            new ValidationException("Invalid data format"));
    }
    
    return await PerformValidationAsync(data);
}

public async Task<Result> ProcessWithErrorHandlingAsync()
{
    try
    {
        var data = await LoadDataAsync();
        return await ProcessDataAsync(data);
    }
    catch (DataLoadException ex)
    {
        // _logger.LogError(ex, "Failed to load data"); // فرض بر وجود لاگر
        return await Task.FromException<Result>(ex);
    }
    catch (ProcessingException ex)
    {
        // _logger.LogError(ex, "Failed to process data"); // فرض بر وجود لاگر
        return await Task.FromException<Result>(ex);
    }
}

public class BusinessException : Exception
{
    public BusinessException(string message) : base(message) { }
}

public async Task<BusinessResult> ProcessBusinessLogicAsync()
{
    if (!IsBusinessRuleValid())
    {
        return await Task.FromException<BusinessResult>(
            new BusinessException("Business rule violation"));
    }
    
    return await ExecuteBusinessLogicAsync();
}

public async Task<Result> ProcessMultipleItemsAsync(IEnumerable<Item> items)
{
    var exceptions = new List<Exception>();
    
    foreach (var item in items)
    {
        try
        {
            await ProcessItemAsync(item);
        }
        catch (Exception ex)
        {
            exceptions.Add(ex);
        }
    }
    
    if (exceptions.Any())
    {
        return await Task.FromException<Result>(
            new AggregateException(exceptions));
    }
    
    return new Result();
}

public async Task<Result> ExecuteWithRetryAsync(
    Func<Task<Result>> operation,
    int maxRetries)
{
    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return await operation();
        }
        catch (Exception ex)
        {
            if (i == maxRetries - 1)
            {
                return await Task.FromException<Result>(
                    new RetryException($"Failed after {maxRetries} attempts", ex));
            }
            
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, i))); // تاخیر نمایی
        }
    }
    
    // این خط نباید قابل دسترسی باشد مگر اینکه مشکلی در منطق وجود داشته باشد
    return await Task.FromException<Result>(
        new InvalidOperationException("Should not reach here"));
}

public class CircuitBreaker
{
    // private readonly ILogger<CircuitBreaker> _logger; // فرض بر وجود لاگر
    private bool _isOpen;
    
    public async Task<Result> ExecuteAsync(Func<Task<Result>> operation)
    {
        if (_isOpen)
        {
            return await Task.FromException<Result>(
                new CircuitBreakerException("Circuit is open"));
        }
        
        try
        {
            return await operation();
        }
        catch (Exception ex)
        {
            _isOpen = true;
            // _logger.LogError(ex, "Circuit breaker opened"); // فرض بر وجود لاگر
            return await Task.FromException<Result>(ex);
        }
    }
}

// خوب
return Task.FromException(new ValidationException("Invalid input"));

// بد
return Task.FromException(new Exception("Invalid input"));

public async Task<Result> ProcessWithContextAsync(InputData data)
{
    try
    {
        return await ProcessAsync(data);
    }
    catch (Exception ex)
    {
        return await Task.FromException<Result>(
            new ProcessingException(
                $"Failed to process data with ID: {data.Id}",
                ex));
    }
}

public async Task<Result> ProcessWithLoggingAsync()
{
    try
    {
        return await ProcessAsync();
    }
    catch (Exception ex)
    {
        // _logger.LogError(ex, "Operation failed"); // فرض بر وجود لاگر
        return await Task.FromException<Result>(ex);
    }
}

public class DataProcessingService
{
    // private readonly ILogger<DataProcessingService> _logger; // فرض بر وجود لاگر
    private readonly IDataValidator _validator;
    private readonly IDataProcessor _processor;
    
    public DataProcessingService(IDataValidator validator, IDataProcessor processor) // سازنده
    {
        _validator = validator;
        _processor = processor;
    }

    public async Task<ProcessedData> ProcessDataAsync(RawData data)
    {
        try
        {
            // اعتبارسنجی ورودی
            if (!await _validator.ValidateAsync(data))
            {
                // _logger.LogWarning("Invalid data received: {@Data}", data); // فرض بر وجود لاگر
                return await Task.FromException<ProcessedData>(
                    new ValidationException("Invalid data format"));
            }
            
            // پردازش داده
            var result = await _processor.ProcessAsync(data);
            
            // اعتبارسنجی خروجی
            if (!IsValid(result)) // فرض بر وجود متد IsValid
            {
                // _logger.LogError("Invalid result generated: {@Result}", result); // فرض بر وجود لاگر
                return await Task.FromException<ProcessedData>(
                    new ProcessingException("Invalid result generated"));
            }
            
            return result;
        }
        catch (Exception ex)
        {
            // _logger.LogError(ex, "Failed to process data: {@Data}", data); // فرض بر وجود لاگر
            return await Task.FromException<ProcessedData>(ex);
        }
    }
}

• اگر داده‌های ورودی نامعتبر باشند، یک ValidationException را در یک تسک خطاخورده بازمی‌گرداند.
• اگر نتیجه پردازش نامعتبر باشد، یک ProcessingException را بازمی‌گرداند.
• برای هر استثنای دیگری که در طول پردازش رخ می‌دهد، استثنا را ثبت کرده و آن را در یک تسک خطاخورده کپسوله می‌کند. این رویکرد تضمین می‌کند که تمامی خطاها به طور سازگار و قابل پیش‌بینی در طول فرایند ناهمگام مدیریت می‌شوند.