C# if文完全マスター：知っておくべき15のテクニックと5つの実践パターン

はじめに

C#のif文は、プログラムの流れを制御する最も基本的かつ重要な構文です。単純な条件分岐から複雑なビジネスロジックまで、適切に使用することでより堅牢なアプリケーションを構築できます。
本記事では、if文の基礎から実践的な使い方まで、具体的なコード例を交えて解説します。

C# if文の基礎知識

if文の基本的な書き方と動作原理

if文は、C#プログラミングにおける最も基本的な制御構文の1つです。特定の条件が真（true）の場合にのみ、指定されたコードブロックを実行する仕組みを提供します。

基本的な構文

// 基本的なif文の構文
if (条件式)
{
    // 条件が真の場合に実行される処理
}

具体的な例

int age = 20;

// 年齢が18歳以上かどうかをチェック
if (age >= 18)
{
    Console.WriteLine("成人です");  // 条件が真なので実行される
}

else文とelse if文による条件分岐の拡張

複数の条件分岐を扱う場合、else文とelse if文を使用します。

int score = 85;

if (score >= 90)
{
    Console.WriteLine("評価：A");
}
else if (score >= 80)
{
    Console.WriteLine("評価：B");  // この行が実行される
}
else if (score >= 70)
{
    Console.WriteLine("評価：C");
}
else
{
    Console.WriteLine("評価：D");
}

条件式で使用できる演算子と比較方法

C#のif文で使用できる主な演算子は以下の通りです。

1. 比較演算子

// 等値比較
if (x == y)    // 等しい
if (x != y)    // 等しくない
if (x < y)     // より小さい
if (x <= y)    // 以下
if (x > y)     // より大きい
if (x >= y)    // 以上

2. 論理演算子

// AND演算子
if (age >= 18 && hasLicense)    // 両方の条件が真
// OR演算子
if (isStudent || isSenior)      // どちらかの条件が真
// NOT演算子
if (!isExpired)                 // 条件の否定

3. 型チェックとパターンマッチング

object obj = "Hello";

// 型チェック
if (obj is string)
{
    string str = (string)obj;
    Console.WriteLine(str.Length);
}

// パターンマッチングを使用した型チェックと変数宣言
if (obj is string message)
{
    Console.WriteLine(message.Length);  // キャスト不要
}

実践的なTipsを示します。

1. 条件式の評価順序に注意する

// 短絡評価の活用
if (obj != null && obj.Value > 0)  // nullチェックを先に行う

2. 複雑な条件はわかりやすく分割する

// 複雑な条件の分割
bool isValidAge = age >= 18 && age <= 65;
bool hasRequiredDocuments = hasLicense && hasInsurance;

if (isValidAge && hasRequiredDocuments)
{
    // 処理
}

3. 比較の一貫性を保つ

// 定数との比較は左辺に定数を置く
const int MINIMUM_AGE = 18;
if (MINIMUM_AGE <= age)  // 数式のような自然な読み方

これらの基本を押さえることで、より効果的なif文の活用が可能になります。
次のセクションでは、これらの基礎知識を活かした実践的な使い方を見ていきましょう。

if文の実践的な使い方

複数条件を組み合わせた高度な条件分岐

実務では、複数の条件を組み合わせて複雑な判断を行う必要があります。以下では、効果的な条件の組み合わせ方を紹介します。

1. 複数条件の論理的なグループ化

// ユーザーの権限チェックの例
if ((isAdmin || isModerator) && !isBlocked)
{
    // 管理者またはモデレーターで、かつブロックされていないユーザー
    ManageContent();
}

2. 複雑な条件のメソッド化

public class UserValidator
{
    private bool IsValidSubscription(User user)
    {
        return user.HasActiveSubscription 
            && !user.IsTrialExpired 
            && user.PaymentStatus == PaymentStatus.Valid;
    }

    private bool HasRequiredPermissions(User user, string operation)
    {
        return user.Permissions.Contains(operation) 
            && user.IsEmailVerified 
            && !user.IsRestricted;
    }

    public bool CanPerformOperation(User user, string operation)
    {
        if (IsValidSubscription(user) && HasRequiredPermissions(user, operation))
        {
            return true;
        }
        return false;
    }
}

三項演算子を使用した条件分岐の簡略化

三項演算子（?:）は、シンプルな条件分岐を1行で記述できる便利な機能です。

// 基本的な使い方
string status = age >= 18 ? "成人" : "未成年";

// 複数の条件の組み合わせ
string grade = score >= 90 ? "A" 
             : score >= 80 ? "B"
             : score >= 70 ? "C"
             : "D";

// メソッドチェーンでの活用
string result = GetUser()
    ?.Profile
    ?.Settings
    ?.Theme
    ?? "default-theme";

nullチェックとnull条件演算子の活用

C#では、nullチェックを効率的に行うための様々な演算子が提供されています。

1. null条件演算子（?.）の使用

// 従来のnullチェック
if (user != null && user.Address != null && user.Address.City != null)
{
    Console.WriteLine(user.Address.City);
}

// null条件演算子を使用
Console.WriteLine(user?.Address?.City); // nullの場合はnullを返す

2. null合体演算子（??）の活用

// デフォルト値の設定
string userName = user?.Name ?? "匿名ユーザー";

// null合体代入演算子（??=）
public class UserPreferences
{
    private List<string> _favorites;

    public List<string> Favorites
    {
        get => _favorites ??= new List<string>(); // nullの場合に初期化
    }
}

3. パターンマッチングとの組み合わせ

public string GetUserInfo(User? user)
{
    if (user is { Name: var name, Age: >= 18 })
    {
        return $"{name}さん（成人）";
    }
    else if (user is { Name: var name })
    {
        return $"{name}さん（未成年）";
    }
    return "ユーザー情報なし";
}

実践的なTips

1. チェーンされたnullチェックの簡略化

// 複数のnullチェックを1行で
var cityName = order?.Customer?.Address?.City ?? "不明";

// コレクションの場合
var firstItem = collection?.FirstOrDefault()?.Name ?? "デフォルト";

2. 条件付きの処理実行

// nullでない場合のみメソッドを実行
user?.UpdateLastLoginDate();

// 条件付きでイベント発生
OnUserUpdated?.Invoke(this, eventArgs);

3. デフォルト値の階層的な設定

public class ConfigurationManager
{
    public string GetSetting(string key)
    {
        return _userSettings?[key] 
            ?? _appSettings?[key] 
            ?? _defaultSettings[key];
    }
}

これらのテクニックを適切に組み合わせることで、より堅牢で保守性の高いコードを作成することができます。
次のセクションでは、if文を使用する際のベストプラクティスについて詳しく見ていきましょう。

if文のベストプラクティス

早期リターンパターンによるネストの削減

深いネストは可読性を低下させ、バグの温床となります。早期リターンパターンを使用することで、コードの可読性と保守性を向上させることができます。

1. 悪い例（ネストが深い）

public bool ProcessOrder(Order order)
{
    if (order != null)
    {
        if (order.Items.Any())
        {
            if (order.PaymentStatus == PaymentStatus.Verified)
            {
                if (CheckInventory(order))
                {
                    // 注文処理
                    return true;
                }
            }
        }
    }
    return false;
}

2. 良い例（早期リターン）

public bool ProcessOrder(Order order)
{
    if (order == null)
        return false;

    if (!order.Items.Any())
        return false;

    if (order.PaymentStatus != PaymentStatus.Verified)
        return false;

    if (!CheckInventory(order))
        return false;

    // 注文処理
    return true;
}

ガード節による可読性の向上

ガード節は、メソッドの先頭で異常系や境界条件をチェックし、早期にリターンする手法です。

public class DocumentProcessor
{
    public ProcessingResult ProcessDocument(Document document, User user)
    {
        // ガード節による入力検証
        if (document == null)
            throw new ArgumentNullException(nameof(document));

        if (user == null)
            throw new ArgumentNullException(nameof(user));

        if (!user.HasPermission(Permission.DocumentProcessing))
            return ProcessingResult.AccessDenied;

        if (document.IsLocked)
            return ProcessingResult.DocumentLocked;

        // メインの処理ロジック
        return PerformDocumentProcessing(document);
    }
}

条件式の最適な記述方法

1. 条件式の簡潔化

// 悪い例
if (isValid == true)  // 冗長
if (count != 0)       // 直感的でない

// 良い例
if (isValid)
if (count > 0)

2. 複合条件の整理

// 悪い例（理解しづらい）
if (age >= 20 && !hasLicense == false && (isStudent || hasPermission) && status == "active")

// 良い例（論理的にグループ化）
bool isQualified = age >= 20 && hasLicense;
bool hasAccess = isStudent || hasPermission;

if (isQualified && hasAccess && status == "active")
{
    // 処理
}

3. 条件式の抽象化

public class UserEligibilityChecker
{
    private bool IsEligibleAge(int age) => age >= 18;

    private bool HasValidDocuments(User user)
    {
        return user.HasIdentification 
            && user.DocumentsVerified;
    }

    private bool IsAccountActive(User user)
    {
        return user.Status == AccountStatus.Active 
            && !user.IsBlocked;
    }

    public bool CanAccessService(User user)
    {
        return IsEligibleAge(user.Age)
            && HasValidDocuments(user)
            && IsAccountActive(user);
    }
}

実装のポイント

1. 条件式の命名規則

// 真偽値を返すメソッドは、質問形式の命名にする
public bool IsValid();
public bool HasPermission();
public bool CanProcess();

2. 否定条件の最小化

// 悪い例（二重否定で理解しづらい）
if (!isNotValid)

// 良い例
if (isValid)

3. デフォルトケースの明確化

public string GetUserType(User user)
{
    // 特殊なケースを先に処理
    if (user.IsAdmin) return "Administrator";
    if (user.IsModerator) return "Moderator";

    // デフォルトケース
    return "Regular User";
}

これらのベストプラクティスを適用することで、より保守性が高く、理解しやすいコードを作成することができます。
次のセクションでは、if文のパフォーマンスについて詳しく見ていきましょう。

パフォーマンスを考慮したif文の実装

条件式の評価順序の最適化

条件式の評価順序は、アプリケーションのパフォーマンスに大きな影響を与える可能性があります。以下では、効率的な条件式の記述方法について説明します。

1. 短絡評価（Short-circuit Evaluation）の活用

public bool ValidateUser(User user)
{
    // 悪い例：重い処理が常に実行される
    if (CheckUserDatabase() && user.Name == "Admin")
    {
        return true;
    }

    // 良い例：軽い処理を先に評価
    if (user.Name == "Admin" && CheckUserDatabase())
    {
        return true;
    }
}

// データベースアクセスを含む重い処理
private bool CheckUserDatabase()
{
    // データベース検証処理
    return true;
}

2. 頻度ベースの条件順序付け

public void ProcessOrder(Order order)
{
    // 悪い例：頻度を考慮していない
    if (order.IsSpecialOrder)  // 発生頻度5%
    {
        ProcessSpecialOrder(order);
    }
    else if (order.IsNormalOrder)  // 発生頻度90%
    {
        ProcessNormalOrder(order);
    }
    else if (order.IsDiscountOrder)  // 発生頻度5%
    {
        ProcessDiscountOrder(order);
    }

    // 良い例：最も頻度の高い条件を最初に評価
    if (order.IsNormalOrder)  // 発生頻度90%
    {
        ProcessNormalOrder(order);
    }
    else if (order.IsSpecialOrder)  // 発生頻度5%
    {
        ProcessSpecialOrder(order);
    }
    else if (order.IsDiscountOrder)  // 発生頻度5%
    {
        ProcessDiscountOrder(order);
    }
}

分岐予測を考慮した条件式の配置

現代のCPUは分岐予測機能を持っており、条件分岐の結果を予測することでパフォーマンスを向上させています。

1. 予測可能な条件分岐の作成

public void ProcessItems(List<Item> items)
{
    // 悪い例：ランダムな条件による分岐
    foreach (var item in items)
    {
        if (new Random().Next(100) > 50)  // 予測不可能
        {
            ProcessHighPriority(item);
        }
        else
        {
            ProcessLowPriority(item);
        }
    }

    // 良い例：ソート済みデータによる予測可能な分岐
    var sortedItems = items.OrderBy(x => x.Priority).ToList();
    foreach (var item in sortedItems)
    {
        if (item.Priority > 50)  // 予測可能
        {
            ProcessHighPriority(item);
        }
        else
        {
            ProcessLowPriority(item);
        }
    }
}

2. 条件分岐の最適化テクニック

public class PerformanceOptimizedProcessor
{
    private readonly Dictionary<ItemType, Action<Item>> _processors;

    public PerformanceOptimizedProcessor()
    {
        _processors = new Dictionary<ItemType, Action<Item>>
        {
            { ItemType.Normal, ProcessNormalItem },
            { ItemType.Special, ProcessSpecialItem },
            { ItemType.Discount, ProcessDiscountItem }
        };
    }

    // 良い例：ディクショナリを使用した高速なルックアップ
    public void ProcessItem(Item item)
    {
        if (_processors.TryGetValue(item.Type, out var processor))
        {
            processor(item);
        }
        else
        {
            ProcessDefaultItem(item);
        }
    }
}

パフォーマンス最適化のポイント

1. キャッシュの活用

public class CachedValidator
{
    private readonly Dictionary<string, bool> _validationCache
        = new Dictionary<string, bool>();

    public bool ValidateWithCache(string key)
    {
        if (_validationCache.TryGetValue(key, out bool result))
        {
            return result;
        }

        result = PerformExpensiveValidation(key);
        _validationCache[key] = result;
        return result;
    }
}

2. 計算コストの削減

public class OptimizedCalculator
{
    // 悪い例：毎回計算を実行
    public double CalculateValue(int x)
    {
        if (Math.Pow(x, 2) > 100)
        {
            return Math.Pow(x, 2);
        }
        return x;
    }

    // 良い例：計算結果を再利用
    public double CalculateValueOptimized(int x)
    {
        var squared = x * x;  // 一度だけ計算
        if (squared > 100)
        {
            return squared;
        }
        return x;
    }
}

これらの最適化技術を適切に適用することで、アプリケーションのパフォーマンスを大幅に向上させることができます。ただし、過度な最適化は可読性を損なう可能性があるため、適切なバランスを取ることが重要です。
次のセクションでは、if文の代替パターンについて見ていきましょう。

if文の代替パターン

switchステートメントとswitch式の活用

従来のif-else文の代替として、より見やすく保守しやすいswitch文やswitch式を活用できます。

1. モダンなswitch式の使用

public decimal CalculateDiscount(CustomerType type, decimal amount)
{
    // 従来のif-else
    if (type == CustomerType.Regular)
        return amount * 0.1m;
    else if (type == CustomerType.Premium)
        return amount * 0.2m;
    else if (type == CustomerType.VIP)
        return amount * 0.3m;
    else
        return 0m;

    // モダンなswitch式
    return type switch
    {
        CustomerType.Regular => amount * 0.1m,
        CustomerType.Premium => amount * 0.2m,
        CustomerType.VIP => amount * 0.3m,
        _ => 0m
    };
}

2. パターンマッチングを活用したswitch

public string DescribeShape(Shape shape)
{
    return shape switch
    {
        Circle c when c.Radius > 10 => $"大きな円（半径: {c.Radius}）",
        Circle c => $"円（半径: {c.Radius}）",
        Rectangle r when r.Width == r.Height => $"正方形（辺: {r.Width}）",
        Rectangle r => $"長方形（幅: {r.Width}, 高さ: {r.Height}）",
        Triangle t => $"三角形（底辺: {t.Base}, 高さ: {t.Height}）",
        _ => "不明な図形"
    };
}

パターンマッチングによる条件分岐

C# 9.0以降で導入された新しいパターンマッチング機能を活用することで、より表現力豊かな条件分岐を実現できます。

1. プロパティパターン

public string ValidateOrder(Order order)
{
    return order switch
    {
        { TotalAmount: > 10000, IsVIP: true } => "VIP高額注文",
        { TotalAmount: > 10000 } => "高額注文",
        { IsVIP: true } => "VIP注文",
        { Items.Count: 0 } => "空の注文",
        _ => "通常注文"
    };
}

2. タプルパターン

public string GetSeasonalGreeting((int month, int day) date)
{
    return date switch
    {
        (12, 25) => "メリークリスマス！",
        (1, 1) => "あけましておめでとう！",
        (3, >= 1 and <= 3) => "ひな祭りシーズン",
        (_, _) when date.month == 12 => "師走です",
        _ => "通常営業日です"
    };
}

ポリモーフィズムを活用した条件分岐の置き換え

複雑な条件分岐は、ポリモーフィズムを使用することでより保守性の高いコードに置き換えることができます。

1. Strategyパターンの活用

// インターフェース定義
public interface IDiscountStrategy
{
    decimal CalculateDiscount(decimal amount);
}

// 具体的な戦略の実装
public class RegularDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(decimal amount) => amount * 0.1m;
}

public class PremiumDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(decimal amount) => amount * 0.2m;
}

public class VIPDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(decimal amount) => amount * 0.3m;
}

// 戦略の使用
public class DiscountCalculator
{
    private readonly Dictionary<CustomerType, IDiscountStrategy> _strategies;

    public DiscountCalculator()
    {
        _strategies = new Dictionary<CustomerType, IDiscountStrategy>
        {
            { CustomerType.Regular, new RegularDiscount() },
            { CustomerType.Premium, new PremiumDiscount() },
            { CustomerType.VIP, new VIPDiscount() }
        };
    }

    public decimal CalculateDiscount(CustomerType type, decimal amount)
    {
        return _strategies.TryGetValue(type, out var strategy)
            ? strategy.CalculateDiscount(amount)
            : 0m;
    }
}

2. State パターンの活用

public interface IOrderState
{
    void Process(Order order);
    IOrderState NextState();
}

public class NewOrderState : IOrderState
{
    public void Process(Order order)
    {
        // 新規注文の処理
        Console.WriteLine("新規注文を処理中");
    }

    public IOrderState NextState() => new ProcessingState();
}

public class ProcessingState : IOrderState
{
    public void Process(Order order)
    {
        // 処理中の注文の処理
        Console.WriteLine("注文処理中");
    }

    public IOrderState NextState() => new CompletedState();
}

public class Order
{
    private IOrderState _state;

    public Order()
    {
        _state = new NewOrderState();
    }

    public void Process()
    {
        _state.Process(this);
        _state = _state.NextState();
    }
}

代替パターン選択のガイドライン

これらの代替パターンを適切に選択することで、より保守性が高く、拡張性のあるコードを作成することができます。
次のセクションでは、これらのパターンを実際のビジネスロジックに適用する例を見ていきましょう。

実践的なコード例と解説

ビジネスロジックにおける条件分岐の実装例

実際のビジネスシーンでは、複雑な要件を満たすために条件分岐を適切に実装する必要があります。
以下では、実践的な例を通じて効果的な実装方法を解説します。

注文処理システムの実装例

public class OrderProcessor
{
    private readonly ILogger _logger;
    private readonly IInventoryService _inventoryService;
    private readonly IPaymentService _paymentService;

    public OrderProcessor(
        ILogger logger,
        IInventoryService inventoryService,
        IPaymentService paymentService)
    {
        _logger = logger;
        _inventoryService = inventoryService;
        _paymentService = paymentService;
    }

    public async Task<OrderResult> ProcessOrder(Order order)
    {
        // ガード節による入力検証
        if (order == null)
            throw new ArgumentNullException(nameof(order));

        if (!order.Items.Any())
            return OrderResult.Failed("注文項目が存在しません");

        try
        {
            // 在庫チェック
            foreach (var item in order.Items)
            {
                var stockResult = await _inventoryService.CheckStock(item.ProductId, item.Quantity);
                if (!stockResult.IsAvailable)
                    return OrderResult.Failed($"商品 {item.ProductId} の在庫が不足しています");
            }

            // 支払い処理
            var paymentResult = await ProcessPayment(order);
            if (!paymentResult.IsSuccess)
                return OrderResult.Failed($"支払い処理に失敗しました: {paymentResult.Message}");

            // 注文確定処理
            await FinalizeOrder(order);

            return OrderResult.Success("注文処理が完了しました");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "注文処理中にエラーが発生しました");
            return OrderResult.Failed("システムエラーが発生しました");
        }
    }

    private async Task<PaymentResult> ProcessPayment(Order order)
    {
        return order.PaymentMethod switch
        {
            PaymentMethod.CreditCard => await ProcessCreditCardPayment(order),
            PaymentMethod.BankTransfer => await ProcessBankTransfer(order),
            PaymentMethod.PointPayment when order.Customer.Points >= order.TotalAmount 
                => await ProcessPointPayment(order),
            _ => PaymentResult.Failed("未対応の支払い方法です")
        };
    }
}

エラーハンドリングでのif文の使用パターン

エラーハンドリングは、アプリケーションの堅牢性を確保する上で重要です。
以下では、効果的なエラーハンドリングパターンを紹介します。

1. Result型を使用したエラーハンドリング

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

public class UserService
{
    private readonly IUserRepository _repository;
    private readonly IPasswordHasher _passwordHasher;

    public async Task<Result<User>> RegisterUser(UserRegistration registration)
    {
        // 入力検証
        if (string.IsNullOrEmpty(registration.Email))
            return Result<User>.Failure("メールアドレスは必須です");

        if (string.IsNullOrEmpty(registration.Password))
            return Result<User>.Failure("パスワードは必須です");

        try
        {
            // メールアドレスの重複チェック
            if (await _repository.ExistsAsync(registration.Email))
                return Result<User>.Failure("このメールアドレスは既に登録されています");

            // ユーザー作成
            var user = new User
            {
                Email = registration.Email,
                PasswordHash = _passwordHasher.HashPassword(registration.Password)
            };

            await _repository.CreateAsync(user);
            return Result<User>.Success(user);
        }
        catch (Exception ex)
        {
            return Result<User>.Failure($"ユーザー登録中にエラーが発生しました: {ex.Message}");
        }
    }
}

ユニットテストを考慮した条件分岐の設計

テスト可能なコードを書くことは、品質維持の観点で非常に重要です。
以下では、テスト可能性を考慮した設計例を示します。

1. テスト可能な設計例

public interface IDiscountCalculator
{
    decimal CalculateDiscount(Order order);
}

public class OrderDiscountCalculator : IDiscountCalculator
{
    private readonly ICustomerService _customerService;
    private readonly IPromotionService _promotionService;

    public OrderDiscountCalculator(
        ICustomerService customerService,
        IPromotionService promotionService)
    {
        _customerService = customerService;
        _promotionService = promotionService;
    }

    public decimal CalculateDiscount(Order order)
    {
        var discount = 0m;

        // 顧客ランクによる割引
        var customerDiscount = GetCustomerDiscount(order.CustomerId);
        if (customerDiscount > 0)
            discount += customerDiscount;

        // キャンペーン割引
        var promotionDiscount = GetPromotionDiscount(order);
        if (promotionDiscount > 0)
            discount += promotionDiscount;

        // 最大割引額のチェック
        return Math.Min(discount, order.TotalAmount * 0.5m);
    }

    private decimal GetCustomerDiscount(int customerId)
    {
        var customer = _customerService.GetCustomer(customerId);
        return customer?.Rank switch
        {
            CustomerRank.Silver => 0.05m,
            CustomerRank.Gold => 0.1m,
            CustomerRank.Platinum => 0.15m,
            _ => 0m
        };
    }

    private decimal GetPromotionDiscount(Order order)
    {
        var activePromotions = _promotionService.GetActivePromotions();
        return activePromotions
            .Where(p => p.IsApplicable(order))
            .Sum(p => p.CalculateDiscount(order));
    }
}

// ユニットテストの例
public class OrderDiscountCalculatorTests
{
    [Fact]
    public void CalculateDiscount_GoldCustomerWithPromotion_ReturnsCorrectDiscount()
    {
        // Arrange
        var customerService = Substitute.For<ICustomerService>();
        customerService.GetCustomer(Arg.Any<int>())
            .Returns(new Customer { Rank = CustomerRank.Gold });

        var promotionService = Substitute.For<IPromotionService>();
        promotionService.GetActivePromotions()
            .Returns(new[] { new FixedAmountPromotion(1000m) });

        var calculator = new OrderDiscountCalculator(
            customerService, promotionService);

        var order = new Order { 
            CustomerId = 1, 
            TotalAmount = 10000m 
        };

        // Act
        var discount = calculator.CalculateDiscount(order);

        // Assert
        Assert.Equal(2000m, discount); // 10% + 1000円の割引
    }
}

これらの実践的な例を参考に、より堅牢で保守性の高いコードを書くことができます。

if文のまとめ

if文は条件分岐の基本でありながら、適切な使用には様々な考慮点があります。パフォーマンス、可読性、保守性のバランスを取りながら、モダンなC#の機能も活用することで、より質の高いコードを書くことができます。
本記事で紹介した手法を実践することで、より堅牢で保守性の高いアプリケーションの開発が可能になるでしょう。