[C#] 入れ子クラス（Nested Class） — クラスの中にクラスを定義する設計テクニック

public class OuterClass
{
    public class PublicInnerClass { }
    private class PrivateInnerClass { }
}

public class Container
{
    public enum Status { Active, Inactive }
    private struct InternalData { public int Id; }
    public interface IHandler { void Handle(); }
    private delegate void Callback(string message);
}

public class BankAccount
{
    private decimal _balance;
    private readonly List<Transaction> _transactions = [];

    public IReadOnlyList<Transaction> GetHistory() =>
        _transactions.AsReadOnly();

    // 外部からは Transaction のコンストラクタにアクセスできない
    public void Deposit(decimal amount)
    {
        _balance += amount;
        _transactions.Add(new Transaction(amount, TransactionType.Deposit));
    }

    // 入れ子クラスは外側の private メンバーにアクセス可能
    public class Transaction
    {
        public decimal Amount { get; }
        public TransactionType Type { get; }
        public DateTime Timestamp { get; }

        // internal コンストラクタで外部アセンブリからの生成を制限
        internal Transaction(decimal amount, TransactionType type)
        {
            Amount = amount;
            Type = type;
            Timestamp = DateTime.UtcNow;
        }
    }

    public enum TransactionType { Deposit, Withdrawal }
}

public class Outer
{
    private int _outerField = 42;

    public void Test()
    {
        var inner = new Inner();
        // コンパイルエラー: 'Inner._innerField' is inaccessible due to its protection level
        // Console.WriteLine(inner._innerField);
    }

    private class Inner
    {
        private int _innerField = 10;

        public void AccessOuter(Outer outer)
        {
            // OK: 入れ子クラスから外側クラスの private メンバーにアクセスできる
            Console.WriteLine(outer._outerField);
        }
    }
}

public class Outer
{
    private int _value = 100;

    private class Inner
    {
        // 外側のインスタンスを明示的に受け取る
        private readonly Outer _outer;

        public Inner(Outer outer) => _outer = outer;

        public int GetOuterValue() => _outer._value;
    }

    public int CreateInnerAndGetValue()
    {
        var inner = new Inner(this);
        return inner.GetOuterValue();
    }
}

// OrderProcessor.cs — 外側クラスの主要ロジック
public partial class OrderProcessor
{
    private readonly IOrderRepository _repository;

    public OrderProcessor(IOrderRepository repository)
    {
        _repository = repository;
    }

    public async Task<OrderResult> ProcessAsync(Order order)
    {
        var validator = new OrderValidator();
        if (!validator.Validate(order))
            return OrderResult.Invalid;

        // 処理ロジック...
        return OrderResult.Success;
    }
}

// OrderProcessor.OrderValidator.cs — 入れ子クラスを別ファイルに分離
public partial class OrderProcessor
{
    // private なのでこのクラスの存在を外部に知らせない
    private class OrderValidator
    {
        public bool Validate(Order order)
        {
            if (order.Items.Count == 0) return false;
            if (order.TotalAmount <= 0) return false;
            return true;
        }
    }
}

public class HtmlDocument
{
    private readonly List<Node> _nodes = [];

    public HtmlDocument Add(string tag, string content)
    {
        _nodes.Add(new ElementNode(tag, content));
        return this;
    }

    public HtmlDocument AddText(string text)
    {
        _nodes.Add(new TextNode(text));
        return this;
    }

    public string Render() =>
        string.Concat(_nodes.Select(n => n.Render()));

    // --- 以下、外部に公開する必要のない実装詳細 ---

    private abstract class Node
    {
        public abstract string Render();
    }

    private class ElementNode : Node
    {
        private readonly string _tag;
        private readonly string _content;

        public ElementNode(string tag, string content)
        {
            _tag = tag;
            _content = content;
        }

        public override string Render() => $"<{_tag}>{_content}</{_tag}>";
    }

    private class TextNode : Node
    {
        private readonly string _text;
        public TextNode(string text) => _text = text;
        public override string Render() => _text;
    }
}

public class NotificationService
{
    public INotification CreateEmail(string to, string subject, string body) =>
        new EmailNotification(to, subject, body);

    public INotification CreateSms(string phoneNumber, string message) =>
        new SmsNotification(phoneNumber, message);

    // 外部からは INotification としてのみ扱える
    public interface INotification
    {
        Task SendAsync();
    }

    // 具象型は private — 外部コードが直接参照・継承できない
    private class EmailNotification : INotification
    {
        private readonly string _to;
        private readonly string _subject;
        private readonly string _body;

        public EmailNotification(string to, string subject, string body)
        {
            _to = to;
            _subject = subject;
            _body = body;
        }

        public async Task SendAsync()
        {
            // SMTP 送信ロジック
        }
    }

    private class SmsNotification : INotification
    {
        private readonly string _phoneNumber;
        private readonly string _message;

        public SmsNotification(string phoneNumber, string message)
        {
            _phoneNumber = phoneNumber;
            _message = message;
        }

        public async Task SendAsync()
        {
            // SMS 送信ロジック
        }
    }
}

public class SlidingWindow<T>
{
    private readonly IReadOnlyList<T> _source;
    private readonly int _windowSize;

    public SlidingWindow(IReadOnlyList<T> source, int windowSize)
    {
        ArgumentOutOfRangeException.ThrowIfLessThanOrEqual(windowSize, 0);
        _source = source;
        _windowSize = windowSize;
    }

    public IEnumerable<IReadOnlyList<T>> GetWindows()
    {
        for (int i = 0; i <= _source.Count - _windowSize; i++)
        {
            yield return new WindowSegment(_source, i, _windowSize);
        }
    }

    // ウィンドウの各セグメントを遅延評価で返す — 外部に公開する必要なし
    private class WindowSegment : IReadOnlyList<T>
    {
        private readonly IReadOnlyList<T> _source;
        private readonly int _offset;
        private readonly int _count;

        public WindowSegment(IReadOnlyList<T> source, int offset, int count)
        {
            _source = source;
            _offset = offset;
            _count = count;
        }

        public T this[int index] => _source[_offset + index];
        public int Count => _count;

        public IEnumerator<T> GetEnumerator()
        {
            for (int i = 0; i < _count; i++)
                yield return _source[_offset + i];
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() =>
            GetEnumerator();
    }
}

public class OrderServiceTests
{
    [Fact]
    public async Task ProcessOrder_ValidOrder_ReturnsSuccess()
    {
        var service = new OrderService(new FakeRepository());
        var result = await service.ProcessAsync(CreateValidOrder());
        Assert.Equal(OrderResult.Success, result);
    }

    // このテストクラスでしか使わないフェイク
    private class FakeRepository : IOrderRepository
    {
        private readonly List<Order> _orders = [];

        public Task SaveAsync(Order order)
        {
            _orders.Add(order);
            return Task.CompletedTask;
        }

        public Task<Order?> FindAsync(int id) =>
            Task.FromResult(_orders.FirstOrDefault(o => o.Id == id));
    }

    private static Order CreateValidOrder() =>
        new() { Id = 1, Items = [new OrderItem("Widget", 1, 9.99m)] };
}

// アンチパターン: 入れ子が深すぎる
public class A
{
    private class B
    {
        private class C  // ここまで来たら設計を見直す
        {
        }
    }
}