Déboguer Error Handling : éviter les pièges courants

La gestion des erreurs est un aspect critique du développement d'applications robustes en .NET. Pourtant, de nombreux développeurs tombent dans des pièges courants qui peuvent compromettre la fiabilité et la maintenabilité de leur code. Dans cet article, nous allons explorer les meilleures pratiques de débogage et de gestion des erreurs en C#, en nous concentrant sur les approches modernes adaptées à .NET 8.

Les fondamentaux de la gestion d'erreurs en C#

Avant d'entrer dans les détails, rappelons les concepts essentiels de la gestion d'erreurs en C# :

• Les exceptions comme mécanisme principal de gestion des erreurs
• La hiérarchie des exceptions dans le framework .NET
• Les blocs try-catch-finally et leur utilisation appropriée

Structure de base d'une gestion d'erreurs

public class OrderProcessor
{
    public async Task ProcessOrder(Order order)
    {
        try
        {
            // Validation des données
            await ValidateOrder(order);
            
            // Traitement principal
            await ProcessOrderInternal(order);
        }
        catch (ValidationException ex)
        {
            // Gestion spécifique des erreurs de validation
            Logger.LogWarning(ex, "Validation failed for order {OrderId}", order.Id);
            throw;
        }
        catch (Exception ex) when (ex is not ValidationException)
        {
            // Gestion générique des autres erreurs
            Logger.LogError(ex, "Error processing order {OrderId}", order.Id);
            throw new OrderProcessingException("Failed to process order", ex);
        }
    }
}

Pièges courants et solutions

1. Catch vide ou trop général

Un des pièges les plus fréquents est l'utilisation de blocs catch trop génériques :

// ❌ À éviter
try
{
    // Code
}
catch (Exception)
{
    // Silence total des erreurs
}

// ✅ Meilleure approche
try
{
    // Code
}
catch (SpecificException ex)
{
    Logger.LogError(ex, "Message contextuel");
    throw;
}

2. Gestion des exceptions asynchrones

Les opérations asynchrones nécessitent une attention particulière :

public class AsyncErrorHandler
{
    public async Task HandleAsync()
    {
        try
        {
            await Task.Run(() => throw new Exception("Async error"));
        }
        catch (Exception ex)
        {
            // L'exception est correctement capturée ici
            await LogAsync(ex);
            throw;
        }
    }
}

Patterns de gestion d'erreurs modernes

Result Pattern

public class Result
{
    public bool IsSuccess { get; }
    public T Value { get; }
    public string Error { get; }

    private Result(bool isSuccess, T value, string error)
    {
        IsSuccess = isSuccess;
        Value = value;
        Error = error;
    }
    public static Result Success(T value) => 
        new Result(true, value, null);
    public static Result Failure(string error) => 
        new Result(false, default, error);
}
// Utilisation
public class UserService
{
    public async Task> CreateUser(UserDto dto)
    {
        try
        {
            var user = await _userRepository.Create(dto);
            return Result.Success(user);
        }
        catch (Exception ex)
        {
            return Result.Failure(ex.Message);
        }
    }
}

Tests et validation

[Fact]
public async Task WhenExceptionOccurs_ShouldReturnFailureResult()
{
    // Arrange
    var service = new UserService(MockRepository());
    var dto = new UserDto { / ... / };

    // Act
    var result = await service.CreateUser(dto);
    // Assert
    Assert.False(result.IsSuccess);
    Assert.NotNull(result.Error);
}

public class RetryPolicy
{
    public async Task ExecuteWithRetry(
        Func> operation,
        int maxAttempts = 3,
        TimeSpan? delay = null)
    {
        var attempts = 0;
        delay ??= TimeSpan.FromSeconds(1);

        while (true)
        {
            try
            {
                attempts++;
                return await operation();
            }
            catch (Exception ex) when (attempts < maxAttempts)
            {
                await Task.Delay(delay.Value);
                delay = TimeSpan.FromTicks(delay.Value.Ticks  2); // Exponential backoff
            }
        }
    }
}

public class ProductionReadyErrorHandler
{
    private readonly ILogger _logger;
    private readonly IMetricsService _metrics;

    public async Task HandleError(Exception ex, string context)
    {
        // Logging structuré
        _logger.LogError(ex, "Error occurred in {Context}", context);
        // Métriques
        _metrics.IncrementErrorCount(context);
        // Notification si nécessaire
        if (ex is CriticalException)
        {
            await NotifyTeam(ex);
        }
    }
}