【C#】カプセル化とアクセス修飾子完全ガイド｜public・private・protected・internal・非対称プロパティ・設計原則まで

// ── カプセル化なし（フィールドが public）──
class BadAccount
{
    public decimal Balance; // 誰でも直接書き換えられる
}

var bad = new BadAccount();
bad.Balance = -99999; // 残高がマイナスになっても誰も止められない

// ── カプセル化あり（プロパティで守る）──
class GoodAccount
{
    private decimal _balance;

    public decimal Balance
    {
        get => _balance;
        private set  // 外部からは設定不可。内部のメソッドだけが変更する
        {
            if (value < 0) throw new InvalidOperationException("残高不足");
            _balance = value;
        }
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("金額は正の値にしてください");
        Balance += amount;
    }

    public void Withdraw(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("金額は正の値にしてください");
        Balance -= amount; // Balance の setter でマイナスチェック
    }
}

var account = new GoodAccount();
account.Deposit(10_000);
account.Withdraw(3_000);
Console.WriteLine(account.Balance); // 7000
// account.Balance = -1; // コンパイルエラー: private set のため変更不可

public class Calculator
{
    // 外部から自由に使える計算メソッド
    public double Add(double a, double b) => a + b;
    public double Sqrt(double x)          => Math.Sqrt(x);
}

// どこからでも呼べる
var calc = new Calculator();
Console.WriteLine(calc.Add(3, 4)); // 7

class PasswordManager
{
    // 外部に公開しない内部データ
    private string _hashedPassword = "";

    // 外部に公開しない内部ヘルパー
    private string Hash(string raw)
        => Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(
               System.Text.Encoding.UTF8.GetBytes(raw)));

    // 外部に公開する操作（private メンバーを内部で使う）
    public void SetPassword(string raw)
        => _hashedPassword = Hash(raw);

    public bool Verify(string raw)
        => _hashedPassword == Hash(raw);
}

var pm = new PasswordManager();
pm.SetPassword("MySecret123");
Console.WriteLine(pm.Verify("MySecret123")); // True
Console.WriteLine(pm.Verify("wrong"));       // False
// pm._hashedPassword = "hack"; // コンパイルエラー

abstract class HttpClientBase
{
    // 子クラスだけが使える HTTP クライアント
    protected readonly HttpClient _http = new();

    // 子クラスだけが使えるログメソッド
    protected void LogRequest(string url)
        => Console.WriteLine($"[Request] {url}");

    public abstract Task<string> FetchAsync(string url);
}

class ApiClient : HttpClientBase
{
    public override async Task<string> FetchAsync(string url)
    {
        LogRequest(url);  // protected メソッドを使える
        return await _http.GetStringAsync(url);  // protected フィールドを使える
    }
}

// 外部からは見えない
// new ApiClient()._http;    // コンパイルエラー
// new ApiClient().LogRequest("x"); // コンパイルエラー

// ── MyLibrary プロジェクト ──

// public: 外部ライブラリの利用者に公開する API
public class UserService
{
    private readonly UserRepository _repo = new();

    public User? FindUser(int id) => _repo.FindById(id);
}

// internal: ライブラリ内部だけで使う実装クラス（外部に見せない）
internal class UserRepository
{
    private readonly List<User> _users = new();
    internal User? FindById(int id)
        => _users.FirstOrDefault(u => u.Id == id);
}

public class User
{
    public int    Id   { get; init; }
    public string Name { get; init; } = "";
}

// ── ConsoleApp プロジェクト（別アセンブリ）──
// var repo = new UserRepository(); // コンパイルエラー: internal のため見えない
// var svc  = new UserService();    // OK: public なのでアクセス可能

// ── Base ライブラリ ──
public class BaseLogger
{
    // 同一アセンブリ内 OR 派生クラスならアクセス可能
    protected internal void WriteLog(string message)
        => Console.WriteLine($"[LOG] {message}");
}

// 同一アセンブリ内: 継承しなくてもアクセスできる
class LogHelper
{
    void Test()
    {
        var logger = new BaseLogger();
        logger.WriteLog("アセンブリ内からアクセス"); // OK
    }
}

// 別アセンブリの派生クラス: 継承しているのでアクセスできる
public class CustomLogger : BaseLogger
{
    public void Custom()
        => WriteLog("派生クラスからアクセス"); // OK
}

// 別アセンブリの非派生クラス: アクセス不可
// class External { void X() { new BaseLogger().WriteLog("…"); } } // エラー

// ── MyFramework ライブラリ ──
public class FrameworkBase
{
    // 同一アセンブリの派生クラスだけに公開する内部フック
    private protected virtual void OnInitialize()
        => Console.WriteLine("基本の初期化");
}

// 同一アセンブリの派生クラス: アクセス可能
internal class InternalExtension : FrameworkBase
{
    private protected override void OnInitialize()
    {
        base.OnInitialize();
        Console.WriteLine("拡張初期化");
    }
}

// 別アセンブリの派生クラス: アクセス不可（external はフレームワーク外）
// public class ExternalExtension : FrameworkBase
// {
//     private protected override void OnInitialize() { } // コンパイルエラー
// }

class Order
{
    // public get / private set: 外部から読み取り専用
    public int    Id       { get; private set; }
    public string Status   { get; private set; } = "Pending";

    // public get / protected set: 子クラスから変更可能
    public decimal TotalAmount { get; protected set; }

    // public get / internal set: 同一アセンブリからのみ変更可能
    public DateTime CreatedAt { get; internal set; } = DateTime.UtcNow;

    // public get / init: オブジェクト初期化子でのみ設定可能（C# 9）
    public string CustomerName { get; init; } = "";

    public Order(int id) => Id = id;

    // ビジネスロジックのメソッドだけが Status を変更できる
    public void Ship()
    {
        if (Status != "Pending")
            throw new InvalidOperationException("出荷済みまたはキャンセル済みです");
        Status = "Shipped"; // private set なのでクラス内からは変更可能
    }
}

var order = new Order(1001) { CustomerName = "Taro" };
Console.WriteLine(order.Status);       // Pending
order.Ship();
Console.WriteLine(order.Status);       // Shipped
// order.Status = "Pending"; // コンパイルエラー: private set

class Money
{
    // コンストラクタで設定後は変更不可
    private readonly decimal _amount;
    private readonly string  _currency;

    public Money(decimal amount, string currency)
    {
        if (amount < 0) throw new ArgumentException("金額は0以上にしてください");
        _amount   = amount;
        _currency = currency;
    }

    public decimal Amount   => _amount;
    public string  Currency => _currency;

    // 新しい Money を返すことで元のオブジェクトは変わらない
    public Money Add(Money other)
    {
        if (_currency != other._currency)
            throw new InvalidOperationException("通貨が異なります");
        return new Money(_amount + other._amount, _currency);
    }

    public override string ToString() => $"{_amount:N0} {_currency}";
}

var price    = new Money(1_000, "JPY");
var tax      = new Money(100,   "JPY");
var total    = price.Add(tax);

Console.WriteLine(total); // 1,100 JPY
// price._amount = 999; // コンパイルエラー: private readonly

// ── MyLibrary プロジェクトの AssemblyInfo.cs または Program.cs ──
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("MyLibrary.Tests")]

// ── MyLibrary プロジェクト ──
internal class OrderValidator
{
    internal bool Validate(string status)
        => status is "Pending" or "Shipped" or "Cancelled";
}

// ── MyLibrary.Tests プロジェクト（別アセンブリ）──
// InternalsVisibleTo により internal クラスにアクセスできる
// [Fact]
// public void Validate_ValidStatus_ReturnsTrue()
// {
//     var v = new OrderValidator(); // OK: InternalsVisibleTo のおかげでアクセス可能
//     Assert.True(v.Validate("Pending"));
// }