এক্সেপশন হ্যান্ডেলিং (Exception Handling)

// Basic try/catch
try
{
    Console.Write("Enter a number: ");
    string input = "not a number"; // simulating bad input
    int number = int.Parse(input); // this will throw!
    Console.WriteLine($"You entered: {number}");
}
catch (FormatException ex)
{
    Console.WriteLine($"That's not a number! Error: {ex.Message}");
}
catch (OverflowException)
{
    Console.WriteLine("That number is too big or too small!");
}
catch (Exception ex)  // catches anything else
{
    Console.WriteLine($"Something went wrong: {ex.Message}");
}
finally
{
    Console.WriteLine("This always runs — cleanup goes here.");
}

// Catching with 'when' filter
try
{
    int[] arr = { 1, 2, 3 };
    Console.WriteLine(arr[10]); // out of bounds!
}
catch (IndexOutOfRangeException ex) when (ex.Message.Contains("index"))
{
    Console.WriteLine("Tried to access an invalid index!");
}

Enter a number: That's not a number! Error: The input string 'not a number' was not in a correct format.
This always runs — cleanup goes here.
Tried to access an invalid index!

// Throwing exceptions — validate your inputs!
static void SetAge(int age)
{
    if (age < 0)
        throw new ArgumentException("Age cannot be negative!", nameof(age));
    if (age > 150)
        throw new ArgumentOutOfRangeException(nameof(age), "Nobody lives that long!");

    Console.WriteLine($"Age set to {age}");
}

// Custom exception class
class InsufficientFundsException : Exception
{
    public decimal Amount { get; }
    public decimal Balance { get; }

    public InsufficientFundsException(decimal amount, decimal balance)
        : base($"Cannot withdraw {amount:C} — only {balance:C} available.")
    {
        Amount = amount;
        Balance = balance;
    }
}

static void Withdraw(decimal balance, decimal amount)
{
    if (amount > balance)
        throw new InsufficientFundsException(amount, balance);
    Console.WriteLine($"Withdrew {amount:C}. Remaining: {balance - amount:C}");
}

// Using them
try { SetAge(25); } catch (Exception ex) { Console.WriteLine(ex.Message); }
try { SetAge(-5); } catch (Exception ex) { Console.WriteLine(ex.Message); }

try
{
    Withdraw(100m, 250m);
}
catch (InsufficientFundsException ex)
{
    Console.WriteLine(ex.Message);
    Console.WriteLine($"  Tried: {ex.Amount:C}, Had: {ex.Balance:C}");
}

Age set to 25
Age cannot be negative! (Parameter 'age')
Cannot withdraw $250.00 — only $100.00 available.
  Tried: $250.00, Had: $100.00

// Instead of try/catch for parsing, use TryParse!
string[] inputs = { "42", "hello", "3.14", "99" };

foreach (string input in inputs)
{
    // TryParse — no exceptions, just true/false
    if (int.TryParse(input, out int result))
    {
        Console.WriteLine($"  '{input}' → {result} (valid!)");
    }
    else
    {
        Console.WriteLine($"  '{input}' → not a valid integer");
    }
}

// Guard clauses — throw early, avoid deep nesting
static string ProcessOrder(string? customerId, int quantity)
{
    // Validate first, fail fast
    if (customerId is null)
        throw new ArgumentNullException(nameof(customerId));
    if (string.IsNullOrWhiteSpace(customerId))
        throw new ArgumentException("Customer ID can't be empty", nameof(customerId));
    if (quantity <= 0)
        throw new ArgumentOutOfRangeException(nameof(quantity), "Must order at least 1");

    // Happy path — no deep nesting!
    return $"Order placed: {quantity} items for customer {customerId}";
}

try
{
    Console.WriteLine(ProcessOrder("C-123", 5));
    Console.WriteLine(ProcessOrder(null, 3));
}
catch (ArgumentNullException ex)
{
    Console.WriteLine($"Missing: {ex.ParamName}");
}

  '42' → 42 (valid!)
  'hello' → not a valid integer
  '3.14' → not a valid integer
  '99' → 99 (valid!)
Order placed: 5 items for customer C-123
Missing: customerId