【C#】例外処理完全ガイド｜try-catch-finally・カスタム例外・throw再スロー・InnerException・設計原則まで

try
{
    // 例外が発生する可能性のある処理
    int result = int.Parse("abc"); // FormatException が発生
}
catch (FormatException ex)
{
    // 特定の例外を捕捉して処理
    Console.WriteLine($"フォーマットエラー: {ex.Message}");
}
catch (Exception ex)
{
    // それ以外のすべての例外を捕捉（最後に配置）
    Console.WriteLine($"予期しないエラー: {ex.Message}");
}
finally
{
    // 例外の有無に関わらず必ず実行される（リソース解放など）
    Console.WriteLine("finally は必ず実行されます");
}

try
{
    // わざと例外を発生させる
    throw new InvalidOperationException("操作が無効です",
        new ArgumentException("引数が不正", "userId"));
}
catch (InvalidOperationException ex)
{
    // Message: 人間が読めるエラーの説明
    Console.WriteLine($"Message: {ex.Message}");
    // → Message: 操作が無効です

    // StackTrace: 例外が発生したメソッドの呼び出し履歴（デバッグ用）
    Console.WriteLine($"StackTrace:
{ex.StackTrace}");

    // InnerException: この例外を引き起こした内側の例外
    if (ex.InnerException is not null)
        Console.WriteLine($"InnerException: {ex.InnerException.Message}");
    // → InnerException: 引数が不正 (Parameter 'userId')

    // GetType(): 実際の例外型
    Console.WriteLine($"Type: {ex.GetType().FullName}");
    // → Type: System.InvalidOperationException

    // Data: 例外に追加情報を付与できるディクショナリ
    ex.Data["RequestId"] = "req-12345";
    Console.WriteLine($"Data: {ex.Data["RequestId"]}");
}

void InnerMethod()
{
    throw new Exception("内部で発生したエラー");
}

// ── NG: throw ex を使うとスタックトレースがリセットされる ──
void BadRethrow()
{
    try
    {
        InnerMethod();
    }
    catch (Exception ex)
    {
        // throw ex は「ここから例外が発生した」と書き換えてしまう
        // InnerMethod() の情報が失われる！
        throw ex; // ← 絶対に使わない
    }
}

// ── OK: throw だけでスタックトレースを保持して再スロー ──
void GoodRethrow()
{
    try
    {
        InnerMethod();
    }
    catch (Exception ex)
    {
        Console.WriteLine($"ログ: {ex.Message}"); // ログだけ取る
        throw; // ← 元のスタックトレースを保持したまま再スロー
    }
}

// ── OK: 別の例外でラップして再スロー（InnerException で元の例外を保持）──
void WrapAndRethrow()
{
    try
    {
        InnerMethod();
    }
    catch (Exception ex)
    {
        // 意味のある例外でラップし、元の例外は InnerException に渡す
        throw new InvalidOperationException("処理に失敗しました", ex); // ← 推奨
    }
}

class UserRepository
{
    public User FindById(int id)
    {
        try
        {
            // DB アクセスの低レベル処理（例: MySQL 接続タイムアウト）
            return FetchFromDatabase(id); // ← SqlException が発生するとする
        }
        catch (Exception dbEx) // SqlException など低レベルな例外
        {
            // 呼び出し側は DB の詳細を知る必要はない
            // → ドメイン意味のある例外でラップして再スロー
            throw new RepositoryException($"ユーザー(id={id})の取得に失敗しました", dbEx);
        }
    }
}

// カスタム例外（次のセクションで詳説）
class RepositoryException : Exception
{
    public RepositoryException(string message, Exception inner)
        : base(message, inner) { }
}

// 呼び出し側のコード
var repo = new UserRepository();
try
{
    var user = repo.FindById(42);
}
catch (RepositoryException ex)
{
    Console.WriteLine(ex.Message);             // ユーザー取得に失敗
    Console.WriteLine(ex.InnerException?.Message); // 元の DB エラーの詳細
}

// 基本パターン: Exception から派生させる
// シリアライズ対応のための3つのコンストラクタを実装するのが慣例
public class DomainException : Exception
{
    // エラーコードなどドメイン固有の情報を持てる
    public string ErrorCode { get; }

    public DomainException()
        : base("ドメインエラーが発生しました") { }

    public DomainException(string message)
        : base(message) { }

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

    public DomainException(string errorCode, string message)
        : base(message)
    {
        ErrorCode = errorCode;
    }
}

// より具体的な派生例外
public class InsufficientFundsException : DomainException
{
    public decimal RequiredAmount { get; }
    public decimal CurrentBalance { get; }

    public InsufficientFundsException(decimal required, decimal current)
        : base("E001", $"残高不足です（必要: {required:C}、現在: {current:C}）")
    {
        RequiredAmount = required;
        CurrentBalance = current;
    }
}

// 使い方
try
{
    decimal balance = 5000m;
    decimal price   = 8000m;
    if (balance < price)
        throw new InsufficientFundsException(price, balance);
}
catch (InsufficientFundsException ex)
{
    Console.WriteLine(ex.Message);       // 残高不足です（必要: ¥8,000、現在: ¥5,000）
    Console.WriteLine(ex.ErrorCode);     // E001
    Console.WriteLine(ex.RequiredAmount); // 8000
}

// ── 旧来の finally パターン ──
StreamReader? reader = null;
try
{
    reader = new StreamReader("data.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"ファイルが見つかりません: {ex.FileName}");
}
finally
{
    reader?.Dispose(); // 例外が起きても必ず解放
}

// ── using ステートメント（同等。より簡潔）──
try
{
    using var reader2 = new StreamReader("data.txt"); // スコープ終了時に自動 Dispose
    string content = reader2.ReadToEnd();
    Console.WriteLine(content);
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"ファイルが見つかりません: {ex.FileName}");
}
// reader2 はここで Dispose() が呼ばれる（例外時も）

// ── using で複数リソースを管理 ──
try
{
    using var input  = new FileStream("input.bin",  FileMode.Open);
    using var output = new FileStream("output.bin", FileMode.Create);
    await input.CopyToAsync(output);
}
catch (IOException ex)
{
    Console.WriteLine($"I/O エラー: {ex.Message}");
}
// input / output の両方が確実に Dispose される

// 非同期メソッドの例外も try-catch で捕捉できる
async Task<string> FetchDataAsync(string url)
{
    using var client = new HttpClient();
    try
    {
        // await で例外が発生するとここで再スローされる
        string response = await client.GetStringAsync(url);
        return response;
    }
    catch (HttpRequestException ex)
    {
        Console.WriteLine($"HTTP エラー: {ex.Message}");
        throw; // 再スロー（throw のみでスタックトレース保持）
    }
}

// 呼び出し側でも catch できる
async Task Main()
{
    try
    {
        string data = await FetchDataAsync("https://example.com/api");
        Console.WriteLine(data);
    }
    catch (HttpRequestException ex)
    {
        Console.WriteLine($"取得失敗: {ex.Message}");
    }
}

// Task.WhenAll は複数タスクの例外をまとめて AggregateException として投げる
async Task ParallelFetch()
{
    var task1 = FetchDataAsync("https://api1.example.com");
    var task2 = FetchDataAsync("https://api2.example.com");

    try
    {
        // 両方完了するまで待機。どちらかが失敗すると例外
        string[] results = await Task.WhenAll(task1, task2);
    }
    catch (HttpRequestException ex)
    {
        // await Task.WhenAll は最初の例外を再スローする
        Console.WriteLine($"いずれかのタスクが失敗: {ex.Message}");

        // すべての例外を確認したい場合は Task オブジェクトの Exception を見る
        foreach (var t in new[] { task1, task2 })
        {
            if (t.IsFaulted)
                Console.WriteLine($"タスク失敗: {t.Exception?.InnerException?.Message}");
        }
    }
}

// NG: 例外を無視する（何も対処しない）
try
{
    ProcessData();
}
catch (Exception)
{
    // 何もしない ← エラーが隠蔽されてデバッグが困難になる
}

// OK: 少なくともログを残す
try
{
    ProcessData();
}
catch (Exception ex)
{
    logger.LogError(ex, "ProcessData で予期しないエラーが発生しました");
    throw; // ログしてから再スロー
}

// NG: Exception（汎用）を先に書くと、後の catch に到達しない
try { /* ... */ }
catch (Exception ex)        { /* ... */ } // ← 先に書くと
catch (FormatException ex2) { /* ... */ } // ← ここには絶対に来ない（コンパイルエラー）

// OK: 具体的な例外から先に書く
try { /* ... */ }
catch (FormatException ex)  { /* ... */ } // 具体的な例外を先に
catch (ArgumentException ex){ /* ... */ }
catch (Exception ex)        { /* ... */ } // 汎用は最後

// NG: Parse で例外ありきの処理（コストが大きい）
string input = "abc";
try
{
    int value = int.Parse(input); // FormatException を前提にしている
    Console.WriteLine(value);
}
catch (FormatException)
{
    Console.WriteLine("数値ではありません");
}

// OK: TryParse で例外なしに処理（パフォーマンス優先）
if (int.TryParse(input, out int result))
    Console.WriteLine(result);
else
    Console.WriteLine("数値ではありません");