Гайд по обработке исключений в C#

public int DivideNumbers(int a, int b, out int result)
{
    if (b == 0)
    {
        result = 0;
        return -1; // Код ошибки: деление на ноль
    }
    
    result = a / b;
    return 0; // Код успеха
}

int resultValue;
int errorCode = DivideNumbers(10, 0, out resultValue);
if (errorCode != 0)
{
    // Обработка ошибки
}

public int DivideNumbers(int a, int b)
{
    if (b == 0)
        throw new DivideByZeroException("Делитель не может быть нулем");
    
    return a / b;
}

try
{
    int result = DivideNumbers(10, 0);
    // Работаем с результатом
}
catch (DivideByZeroException ex)
{
    // Обработка конкретной ошибки
}

try
{
    // Код, который может вызвать исключение
    File.ReadAllText("несуществующий_файл.txt");
}
catch (FileNotFoundException ex)
{
    // Фаза обработки исключения
    Console.WriteLine($"Произошла ошибка: {ex.Message}");
}

// Пример системного исключения
int[] numbers = new int[5];
int value = numbers[10]; // Вызовет IndexOutOfRangeException

// Создание прикладного исключения
public class OrderProcessingException : Exception
{
    public OrderProcessingException(string message) : base(message) { }
}
 
// Использование
if (order.Items.Count == 0)
{
    throw new OrderProcessingException("Заказ не может быть пустым");
}

void MethodA()
{
    try { MethodB(); }
    catch(Exception ex) { /* Обработка */ }
}
 
void MethodB() { MethodC(); }
 
void MethodC() { throw new Exception(); }

// Медленно: использование исключения
try 
{
    var result = array[potentiallyInvalidIndex];
} 
catch (IndexOutOfRangeException) 
{
    result = defaultValue;
}
 
// Быстро: предварительная проверка
if (potentiallyInvalidIndex >= 0 && potentiallyInvalidIndex < array.Length)
{
    result = array[potentiallyInvalidIndex];
}
else
{
    result = defaultValue;
}

// Плохо: перехват всего
try { ProcessData(); }
catch (Exception) { /* проглатывание ошибки */ }
 
// Хорошо: перехват конкретного типа
try { ProcessData(); }
catch (FormatException ex) 
{ 
    // Целенаправленная обработка ошибки формата
    LogError(ex);
    UseDefaultFormat();
}

try
{
    _repository.SaveCustomer(customer);
}
catch (DbException ex)
{
    throw new CustomerSaveException("Не удалось сохранить информацию о клиенте", ex);
}

try
{
    ProcessOrder(order);
}
catch (OrderException ex) when (ex.OrderId > 1000 && ex.OrderId < 2000)
{
    // Обработка для конкретного диапазона заказов
}

try
{
    // Код, вызывающий исключение
}
catch (Exception ex)
{
    Console.WriteLine($"Сообщение: {ex.Message}");
    Console.WriteLine($"Тип исключения: {ex.GetType().Name}");
    Console.WriteLine($"Стек вызовов: {ex.StackTrace}");
    Console.WriteLine($"Источник: {ex.Source}");
    
    if (ex.InnerException != null)
        Console.WriteLine($"Вложенное исключение: {ex.InnerException.Message}");
}

try
{
    // Потенциально проблемный код
    int result = 10 / userInput;
    File.ReadAllText(filePath);
}

catch (DivideByZeroException ex)
{
    Console.WriteLine("Деление на ноль недопустимо!");
    // Восстановление после ошибки
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"Файл не найден: {ex.FileName}");
    // Альтернативная стратегия
}

finally
{
    if (connection != null && connection.State == ConnectionState.Open)
        connection.Close();
    
    Console.WriteLine("Выполнение блока finally");
}

FileStream file = null;
try
{
    file = new FileStream("document.txt", FileMode.Open);
    // Работаем с файлом
    ProcessFile(file);
}
catch (IOException ex)
{
    Console.WriteLine($"Ошибка ввода-вывода: {ex.Message}");
    // Обработка ошибки
}
finally
{
    // Гарантированное освобождение ресурса
    if (file != null)
        file.Close();
}

public int DivideWithFinally(int a, int b)
{
try
{
    if (b == 0)
        return -1; // Преждевременный выход
    
    return a / b;  // Обычный выход
}
finally
{
    Console.WriteLine("Блок finally выполнился");
    // Этот код выполнится ДО возврата значения из метода!
}
}

for (int i = 0; i < 5; i++)
{
try
{
    if (i == 3)
        continue; // Пропуск итерации
    
    Console.WriteLine($"Итерация {i}");
}
finally
{
    Console.WriteLine($"Finally для итерации {i}");
    // Выполняется даже при continue
}
}

try
{
    // Код, вызывающий исключение
}
catch (Exception ex)
{
    Logger.Log(ex);
    throw; // Сохраняет оригинальный стек вызовов
}

try
{
    // Код, вызывающий исключение
}
catch (Exception ex)
{
    Logger.Log(ex);
    throw ex; // Сбрасывает стек вызовов до текущей точки
}

try
{
    // Код, вызывающий исключение
}
catch (SqlException ex)
{
    throw new DataAccessException("Ошибка при работе с базой данных", ex);
}

// Вместо явного try-finally
using (FileStream file = new FileStream("log.txt", FileMode.Open))
{
// Работа с файлом
byte[] buffer = new byte[1024];
file.Read(buffer, 0, buffer.Length);
}
// Здесь file.Dispose() будет вызван автоматически

{
FileStream file = new FileStream("log.txt", FileMode.Open);
try
{
// Работа с файлом
byte[] buffer = new byte[1024];
file.Read(buffer, 0, buffer.Length);
}
finally
{
if (file != null)
    ((IDisposable)file).Dispose();
}
}

using var reader = new StreamReader("data.txt");
// Область видимости reader — до конца текущего блока
// Dispose() будет вызван автоматически при выходе из блока

try
{
    // Код, который может вызвать различные исключения
    ProcessFile("data.txt");
}
catch (FileNotFoundException ex)
{
    LogError("Файл не найден", ex);
    UseBackupFile();
}
catch (UnauthorizedAccessException ex)
{
    LogError("Нет доступа к файлу", ex);
    UseBackupFile();
}

try
{
    ProcessFile("data.txt");
}
catch (Exception ex) when (ex is FileNotFoundException || ex is UnauthorizedAccessException)
{
    LogError("Проблема с доступом к файлу", ex);
    UseBackupFile();
}

try
{
    ProcessFile("data.txt");
}
catch (FileNotFoundException or UnauthorizedAccessException ex)
{
    LogError("Проблема с доступом к файлу", ex);
    UseBackupFile();
}

public class DatabaseConnection
{
private SqlConnection connection;
 
public DatabaseConnection(string connectionString)
{
// Если здесь возникнет исключение - объект не будет создан
connection = new SqlConnection(connectionString);
connection.Open(); // Может выбросить SqlException
// Код ниже не выполнится при исключении!
connection.ChangeDatabase("master");
}
 
~DatabaseConnection()
{
// Опасно! Исключения в деструкторах могут завершить приложение
try
{
    connection?.Close();
}
catch (Exception)
{
    // Глотаем исключение - у нас нет выбора
}
}
}

// Простой пример пользовательского исключения
public class OrderValidationException : Exception
{
    public string OrderId { get; }
    public ValidationErrorType ErrorType { get; }
 
    public OrderValidationException(string orderId, ValidationErrorType errorType, string message)
        : base(message)
    {
        OrderId = orderId;
        ErrorType = errorType;
    }
}

async Task<int> DangerousMethodAsync()
{
throw new InvalidOperationException("Что-то пошло не так");
return 42;
}
 
async Task CallerAsync()
{
try
{
await DangerousMethodAsync(); // Исключение "всплывет" здесь
}
catch (InvalidOperationException ex)
{
// Исключение поймано
}
}

// Опасно! Исключение не будет поймано
Task task = DangerousMethodAsync();
// Никакого await, исключение "похоронено" в task.Exception

try
{
await Task.WhenAll(task1, task2);
}
catch (AggregateException ex)
{
foreach (var innerEx in ex.InnerExceptions)
{
// Обработка каждого исключения
}
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class ExceptionDocAttribute : Attribute
{
    public Type ExceptionType { get; }
    public string Description { get; }
 
    public ExceptionDocAttribute(Type exceptionType, string description)
    {
        ExceptionType = exceptionType;
        Description = description;
    }
}

[ExceptionDoc(typeof(ArgumentNullException), "Вызывается, если параметр userId равен null")]
[ExceptionDoc(typeof(UserNotFoundException), "Вызывается, если пользователь не найден в системе")]
public User GetUserById(string userId)
{
    if (userId == null)
        throw new ArgumentNullException(nameof(userId));
    
    // Логика поиска пользователя
}

public class ECommerceException : Exception
{
    public string TransactionId { get; }
 
    public ECommerceException(string message) : base(message) { }
    
    public ECommerceException(string message, string transactionId) 
        : base(message)
    {
        TransactionId = transactionId;
    }
    
    public ECommerceException(string message, Exception innerException) 
        : base(message, innerException) { }
}

public class PaymentFailedException : ECommerceException 
{
    public PaymentFailureReason Reason { get; }
    
    public PaymentFailedException(string message, PaymentFailureReason reason)
        : base(message)
    {
        Reason = reason;
    }
}

public OrderDetails GetOrderById(string orderId)
{
    try
    {
        return _repository.FindOrder(orderId);
    }
    catch (DbException ex)
    {
        throw new OrderOperationException("Не удалось получить данные заказа", ex);
    }
}

public Result<OrderDetails> TryGetOrder(string orderId)
{
    try
    {
        var order = _repository.FindOrder(orderId);
        return Result<OrderDetails>.Success(order);
    }
    catch (Exception ex)
    {
        return Result<OrderDetails>.Failure(ex.Message);
    }
}

// Плохо: слишком широкий охват
try
{
PrepareData();
ProcessBusinessLogic();
SaveResults();
NotifyUser();
}
catch (Exception ex) { ... }
 
// Хорошо: каждая логическая операция защищена отдельно
try { PrepareData(); }
catch (DataFormatException ex) { ... }
 
try { ProcessBusinessLogic(); }
catch (BusinessRuleException ex) { ... }

catch (Exception ex)
{
_logger.Error(ex, "Ошибка обработки заказа {OrderId} для пользователя {UserId}", 
              order.Id, currentUser.Id);
}

try
{
Parallel.ForEach(items, item =>
{
if (item.IsCorrupted)
    throw new DataCorruptionException(item.Id);
});
}
catch (AggregateException ae)
{
// Обработка всех вложенных исключений
foreach (var ex in ae.InnerExceptions)
{
    Console.WriteLine($"Параллельная ошибка: {ex.Message}");
}
}

try
{
var results = await Task.WhenAll(
    ProcessFileAsync("file1.txt"),
    ProcessFileAsync("file2.txt")
);
}
catch (FileNotFoundException ex)
{
// Перехват конкретного исключения из любой задачи
}

var tasks = new[]
{
ProcessFileAsync("file1.txt"),
ProcessFileAsync("file2.txt")
};
 
try
{
await Task.WhenAll(tasks);
}
catch
{
// Собираем все возникшие ошибки
var exceptions = tasks
    .Where(t => t.IsFaulted)
    .Select(t => t.Exception.InnerException);
}

public void ProcessData(string data)
{
if (string.IsNullOrEmpty(data)) // Предварительная проверка
{
Console.WriteLine("Данные отсутствуют");
return;
}
 
// Продолжаем обработку данных
}

public void ConnectToDatabase(string connectionString)
{
// Здесь мы не проверяем успех подключения заранее,
// потому что неудача - действительно исключительная ситуация
_connection.Open(); // Может выбросить SqlException
}

public Order ProcessOrder(OrderRequest request)
{
if (request == null)
    throw new ArgumentNullException(nameof(request));
if (request.Items.Count == 0)
    throw new OrderValidationException("Заказ не может быть пустым");
    
// Продолжаем только если все проверки пройдены
}

public ProcessingResult ProcessOrder(OrderRequest request)
{
try 
{
    // Полная обработка заказа
    return ProcessingResult.Success(ProcessCompleteOrder(request));
}
catch (InventoryException)
{
    // Продолжаем работу, но с ограничениями
    return ProcessingResult.Partial(ProcessPartialOrder(request));
}
catch (Exception ex)
{
    return ProcessingResult.Failure(ex.Message);
}
}

public void CreateCustomer(Customer customer)
{
    try
    {
        _repository.Save(customer);
    }
    catch (DbException ex)
    {
        throw new CustomerRegistrationException(
            $"Не удалось зарегистрировать клиента {customer.Name}", ex);
    }
}