自定义异常 #

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

public class ValidationException : Exception
{
    public string PropertyName { get; }
    public object AttemptedValue { get; }
    
    public ValidationException(string propertyName, object attemptedValue, string message)
        : base(message)
    {
        PropertyName = propertyName;
        AttemptedValue = attemptedValue;
    }
    
    public ValidationException(string propertyName, object attemptedValue, string message, Exception innerException)
        : base(message, innerException)
    {
        PropertyName = propertyName;
        AttemptedValue = attemptedValue;
    }
}

public class ApiException : Exception
{
    public int ErrorCode { get; }
    public string ErrorDetails { get; }
    
    public ApiException(int errorCode, string message)
        : base(message)
    {
        ErrorCode = errorCode;
    }
    
    public ApiException(int errorCode, string message, string details)
        : base(message)
    {
        ErrorCode = errorCode;
        ErrorDetails = details;
    }
    
    public override string ToString()
    {
        return $"[{ErrorCode}] {Message}\n{ErrorDetails}";
    }
}

[Serializable]
public class DomainException : Exception
{
    public string Domain { get; }
    
    public DomainException() { }
    
    public DomainException(string message) : base(message) { }
    
    public DomainException(string message, Exception innerException)
        : base(message, innerException) { }
    
    public DomainException(string domain, string message)
        : base(message)
    {
        Domain = domain;
    }
    
    protected DomainException(SerializationInfo info, StreamingContext context)
        : base(info, context)
    {
        Domain = info.GetString(nameof(Domain));
    }
    
    public override void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        base.GetObjectData(info, context);
        info.AddValue(nameof(Domain), Domain);
    }
}

public class UserService
{
    public void Register(string username, string password)
    {
        if (string.IsNullOrEmpty(username))
            throw new ValidationException("username", username, "用户名不能为空");
        
        if (password.Length < 6)
            throw new ValidationException("password", password, "密码长度不能少于6位");
        
        if (_userRepository.Exists(username))
            throw new BusinessException("用户名已存在");
    }
}

try
{
    _userService.Register(username, password);
}
catch (ValidationException ex)
{
    Console.WriteLine($"验证失败：{ex.PropertyName} - {ex.Message}");
}
catch (BusinessException ex)
{
    Console.WriteLine($"业务错误：{ex.Message}");
}

public class OrderService
{
    public void ProcessOrder(int orderId)
    {
        try
        {
            var order = _orderRepository.GetById(orderId);
            ValidateOrder(order);
            ProcessPayment(order);
        }
        catch (PaymentException ex)
        {
            throw new OrderProcessingException("订单处理失败", ex);
        }
    }
}

public class EntityValidationException : Exception
{
    public Type EntityType { get; }
    public IDictionary<string, string[]> ValidationErrors { get; }
    
    public EntityValidationException(Type entityType, IDictionary<string, string[]> errors)
        : base($"验证失败：{entityType.Name}")
    {
        EntityType = entityType;
        ValidationErrors = errors;
    }
    
    public override string Message
    {
        get
        {
            var errors = ValidationErrors.SelectMany(kvp => 
                kvp.Value.Select(v => $"{kvp.Key}: {v}"));
            return $"{base.Message}\n{string.Join("\n", errors)}";
        }
    }
}

public class ConfigurationMissingException : Exception
{
    public string Key { get; }
    public string Section { get; }
    
    public ConfigurationMissingException(string key, string section = null)
        : base($"配置项缺失：{key}")
    {
        Key = key;
        Section = section;
    }
}

public class ConcurrencyException : Exception
{
    public string EntityName { get; }
    public object EntityId { get; }
    public int ExpectedVersion { get; }
    public int ActualVersion { get; }
    
    public ConcurrencyException(string entityName, object entityId, 
        int expectedVersion, int actualVersion)
        : base($"并发冲突：{entityName}({entityId}) 期望版本{expectedVersion}，实际版本{actualVersion}")
    {
        EntityName = entityName;
        EntityId = entityId;
        ExpectedVersion = expectedVersion;
        ActualVersion = actualVersion;
    }
}

public class PermissionDeniedException : Exception
{
    public string UserId { get; }
    public string RequiredPermission { get; }
    public string Resource { get; }
    
    public PermissionDeniedException(string userId, string permission, string resource = null)
        : base($"权限不足：用户{userId}没有{permission}权限")
    {
        UserId = userId;
        RequiredPermission = permission;
        Resource = resource;
    }
}

public abstract class AppException : Exception
{
    public string Code { get; }
    public Severity Severity { get; }
    
    protected AppException(string code, string message, Severity severity = Severity.Error)
        : base(message)
    {
        Code = code;
        Severity = severity;
    }
    
    protected AppException(string code, string message, Exception innerException, 
        Severity severity = Severity.Error)
        : base(message, innerException)
    {
        Code = code;
        Severity = severity;
    }
}

public enum Severity { Info, Warning, Error, Critical }

public class NotFoundException : AppException
{
    public string EntityType { get; }
    public object Id { get; }
    
    public NotFoundException(string entityType, object id)
        : base("NOT_FOUND", $"{entityType}未找到：{id}", Severity.Warning)
    {
        EntityType = entityType;
        Id = id;
    }
}

public class ConflictException : AppException
{
    public ConflictException(string message)
        : base("CONFLICT", message, Severity.Warning)
    {
    }
}

public class UserNotFoundException : Exception { }
public class InvalidCredentialsException : Exception { }
public class InsufficientFundsException : Exception { }

throw new UserNotFoundException($"用户ID {userId} 不存在");

try
{
    await SaveToDatabaseAsync(user);
}
catch (SqlException ex)
{
    throw new UserSaveException("保存用户失败", ex);
}

try
{
    ProcessOrder(order);
}
catch (OrderValidationException ex)
{
}
catch (OrderProcessingException ex)
{
}
catch (OrderException ex)
{
}