‫درک توسعه مبتنی بر استثناء (Exception-Driven Development): یک ضدالگو در برنامه‌نویسی

• استفاده مکرر از بلوک‌های try-catch برای عملیات روتین.
• بلوک‌های catch خالی یا بلوک‌هایی که استثناها را بدون مدیریت معنادار می‌بلعند (swallow exceptions).
• استفاده از استثناها برای اعتبارسنجی یا شرایط خطای مورد انتظار.
• جریان کنترلی که به پرتاب شدن استثناهای خاص بستگی دارد.
• متدها یا APIهایی که برای پرتاب استثناها به عنوان بخشی از عملیات عادی خود طراحی شده‌اند.

public void ProcessUser(string username)
{
    try
    {
        // Directly try to process without validation
        if (username.Length < 3) // Potential NullReferenceException if username is null
        {
            Console.WriteLine("Username too short");
        }
        // Further processing...
    }
    catch (NullReferenceException)
    {
        Console.WriteLine("Username cannot be null");
    }
}

public void ProcessUser(string username)
{
    if (username == null)
    {
        Console.WriteLine("Username cannot be null");
        return;
    }
    
    if (username.Length < 3)
    {
        Console.WriteLine("Username too short");
    }
    // Further processing...
}

public string ReadFileContents(string filePath)
{
    try
    {
        return File.ReadAllText(filePath); // Potential FileNotFoundException
    }
    catch (FileNotFoundException)
    {
        return "File not found";
    }
}

public string ReadFileContents(string filePath)
{
    if (!File.Exists(filePath))
    {
        return "File not found";
    }
    
    return File.ReadAllText(filePath);
}

public string GetValue(Dictionary<string, string> dictionary, string key)
{
    try
    {
        return dictionary[key]; // Potential KeyNotFoundException
    }
    catch (KeyNotFoundException)
    {
        return "Key not found";
    }
}

public string GetValue(Dictionary<string, string> dictionary, string key)
{
    if (dictionary.TryGetValue(key, out string value))
    {
        return value;
    }
    return "Key not found";
}

public int ConvertToInt(string input)
{
    try
    {
        return int.Parse(input); // Potential FormatException
    }
    catch (FormatException)
    {
        return 0; // Default value on failure
    }
}

public int ConvertToInt(string input)
{
    if (int.TryParse(input, out int result))
    {
        return result;
    }
    return 0; // Default value on failure
}

• خرابی مورد انتظار (Expected failure): شرایطی که معمولاً در طول عملیات عادی رخ می‌دهد، مانند وارد کردن داده نامعتبر توسط کاربر یا عدم وجود یک فایل.
• شرایط استثنایی (Exceptional condition): یک وضعیت نادر یا غیرمنتظره که نشان می‌دهد مشکلی جدی رخ داده است.

public void SaveDocument(Document document, string path)
{
    if (document == null)
        throw new ArgumentNullException(nameof(document)); // Contract violation
    if (string.IsNullOrEmpty(path))
        throw new ArgumentException("Path cannot be empty", nameof(path)); // Contract violation

    // Normal validation completed, now we can proceed
    try
    {
        // This could still fail for exceptional reasons (disk full, permissions)
        File.WriteAllText(path, document.Content);
    }
    catch (IOException ex)
    {
        // Handle truly exceptional condition
        LogError($"Failed to save document: {ex.Message}");
        throw new DocumentSaveException("Could not save the document", ex);
    }
}

// Example of a TryPattern method signature
public bool TryGetUserDetails(string userId, out UserDetails details)
{
    // Implementation that returns true for success, false for failure
    // and populates 'details' when successful
    details = null; // Placeholder for actual implementation
    // ... logic to get user details ...
    if (/* condition for success */ true) {
        // details = ...;
        return true;
    }
    return false;
}

// Usage:
if (TryGetUserDetails("user123", out var userDetails))
{
    // Use userDetails
}
else
{
    // Handle failure case
}

public class Result<T>
{
    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<T> Success(T value) => new Result<T>(true, value, null);
    public static Result<T> Failure(string error) => new Result<T>(false, default, error);
}

// Usage example:
public Result<User> GetUser(string id) // Assuming User class and _repository exist
{
    if (string.IsNullOrEmpty(id))
    {
        return Result<User>.Failure("ID cannot be empty");
    }
    // User user = _repository.FindById(id); // Placeholder
    User user = null; // Placeholder for actual repository call
    if (user == null)
    {
        return Result<User>.Failure("User not found");
    }
    return Result<User>.Success(user);
}

// Client code:
// var result = GetUser("123");
// if (result.IsSuccess)
// {
//     Console.WriteLine($"Found user: {result.Value.Name}");
// }
// else
// {
//     Console.WriteLine($"Error: {result.Error}");
// }

public void ProcessOrder(Order order) // Assuming Order class exists
{
    // Guard clauses
    if (order == null)
        throw new ArgumentNullException(nameof(order)); // Appropriate exception for contract violation
    // if (order.Items.Count == 0) // Assuming Items property exists
    //     return; 
    // if (!order.IsValid) // Assuming IsValid property exists
    //     return;
    // Main processing logic follows
    // ...
}

public decimal CalculateTax(string incomeText)
{
    try
    {
        decimal income = decimal.Parse(incomeText);
        return income * 0.2m;
    }
    catch (FormatException)
    {
        return 0;
    }
}

public decimal CalculateTax(string incomeText)
{
    if (decimal.TryParse(incomeText, out decimal income))
    {
        return income * 0.2m;
    }
    return 0;
}

// Assuming _customerRepository and Customer class exist
public Customer GetCustomer(int id)
{
    try
    {
        return _customerRepository.Get(id); // Potential CustomerNotFoundException
    }
    catch (CustomerNotFoundException)
    {
        return new Customer { Name = "Unknown" };
    }
}

// Assuming _customerRepository.Exists(id) and _customerRepository.Get(id) methods exist
public Customer GetCustomer(int id)
{
    if (_customerRepository.Exists(id))
    {
        return _customerRepository.Get(id);
    }
    return new Customer { Name = "Unknown" };
}

// Assuming Result<T>, Customer class, and _customerRepository exist
public Result<Customer> GetCustomer(int id)
{
    if (!_customerRepository.Exists(id)) // Assumes Exists method
    {
        return Result<Customer>.Failure($"Customer with id {id} not found");
    }
    
    try
    {
        var customer = _customerRepository.Get(id); // Assumes Get method
        return Result<Customer>.Success(customer);
    }
    catch (Exception ex) // Catching broader exceptions for unexpected issues during retrieval
    {
        // Log the exception (e.g., LogError(ex.Message);)
        return Result<Customer>.Failure($"Error retrieving customer: {ex.Message}");
    }
}

• کاهش قابلیت نگهداری (Maintainability): درک و نگهداری کدی که از استثناها برای جریان کنترل استفاده می‌کند، دشوارتر است. توسعه‌دهندگان جدید ممکن است در دنبال کردن مسیر اجرا دچار مشکل شوند.
• کاهش عملکرد (Performance): همانطور که قبلاً ذکر شد، استثناها به طور قابل توجهی گران‌تر از جریان کنترل عادی هستند و می‌توانند منجر به کندی محسوس در برنامه‌های حساس به عملکرد شوند.
• ابهام در قصد (Obscured Intent): کد مبتنی بر استثناء اغلب قصد اصلی توسعه‌دهنده را پنهان می‌کند.
• کد شکننده (Brittle Code): EDD اغلب منجر به کدی شکننده می‌شود که با تغییر پیاده‌سازی‌های زیربنایی به روش‌های غیرمنتظره‌ای می‌شکند. برای مثال، اگر یک API دیگر یک استثناء خاص را پرتاب نکند، کدی که به گرفتن آن استثناء متکی است، نادرست رفتار خواهد کرد.