【C#】プロパティとフィールド完全ガイド｜バッキングフィールド・required・INotifyPropertyChanged・インデクサーまで

class FieldExamples
{
    // 通常フィールド（インスタンスごとに独立）
    private int _count;

    // readonly: コンストラクタ内でのみ設定可（以後変更不可）
    private readonly string _id;

    // const: コンパイル時定数（static かつ readonly 相当）
    private const double Pi = 3.14159265358979;

    // static: すべてのインスタンスで共有
    private static int _instanceCount = 0;

    // static readonly: 実行時定数（const と異なりオブジェクトも可）
    private static readonly DateTime AppStarted = DateTime.UtcNow;

    // volatile: マルチスレッド時に最新値を読む（CPU キャッシュを経由しない）
    private volatile bool _isRunning;

    public FieldExamples(string id)
    {
        _id = id;                   // readonly はコンストラクタで設定
        _instanceCount++;
    }
}

// 書いたコード
public class Person
{
    public string Name { get; set; } = "";
}

// コンパイラが生成する（擬似コード）
public class Person
{
    [CompilerGenerated]
    private string <Name>k__BackingField = "";   // バッキングフィールド

    public string Name
    {
        [CompilerGenerated]
        get => <Name>k__BackingField;            // get メソッド

        [CompilerGenerated]
        set => <Name>k__BackingField = value;    // set メソッド
    }
}

public class Temperature
{
    private double _celsius;

    public double Celsius
    {
        get => _celsius;
        set
        {
            if (value < -273.15)
                throw new ArgumentOutOfRangeException(nameof(value), "絶対零度より低い値は無効です");
            _celsius = value;
        }
    }

    // 計算プロパティ: バッキングフィールドなしで算出
    public double Fahrenheit => _celsius * 9 / 5 + 32;
    public double Kelvin     => _celsius + 273.15;
}

var t = new Temperature { Celsius = 100.0 };
Console.WriteLine(t.Fahrenheit); // 212
Console.WriteLine(t.Kelvin);     // 373.15

public class Document
{
    private readonly string _text;
    private int? _wordCount;   // null = 未計算

    public Document(string text) => _text = text;

    // 初回アクセス時にのみ計算してキャッシュ
    public int WordCount => _wordCount ??= CountWords(_text);

    private static int CountWords(string text)
        => text.Split(new[] { ' ', '
', '	' }, StringSplitOptions.RemoveEmptyEntries).Length;
}

var doc = new Document("Hello World C# is great");
Console.WriteLine(doc.WordCount); // 5（ここで初めて計算）
Console.WriteLine(doc.WordCount); // 5（キャッシュから返る）

// init: オブジェクト初期化子でのみ設定可（以後変更不可）
public class Order
{
    public Guid   Id       { get; init; } = Guid.NewGuid();
    public string Customer { get; init; } = "";
    public decimal Amount  { get; init; }
}

var order = new Order { Customer = "Taro", Amount = 9800m };
// order.Customer = "Hanako"; // CS8852: init専用プロパティへの代入エラー

// 非対称アクセス修飾子: 外部からは読み取り専用、継承先からは書き込み可
public class BaseEntity
{
    public DateTime CreatedAt { get; protected set; } = DateTime.UtcNow;
    public DateTime UpdatedAt { get; private set; }   = DateTime.UtcNow;

    protected void Touch() => UpdatedAt = DateTime.UtcNow;
}

public class UserDto
{
    public required string Name  { get; init; }   // 必須
    public required string Email { get; init; }   // 必須
    public string Role { get; init; } = "User";   // 任意（デフォルトあり）
}

// OK: required プロパティをすべて設定
var user = new UserDto
{
    Name  = "Taro",
    Email = "taro@example.com"
    // Role は省略可（デフォルト値 "User" が使われる）
};

// コンパイルエラー: CS9035 — Name と Email が必要です
// var invalid = new UserDto { Name = "Taro" };

// インターフェースでプロパティを定義
public interface IShape
{
    double Area      { get; }         // 読み取り専用プロパティ（実装必須）
    double Perimeter { get; }
    string Color     { get; set; }    // 読み書き両方（実装必須）
}

public class Circle : IShape
{
    private readonly double _radius;
    public Circle(double radius) => _radius = radius;

    public double Area      => Math.PI * _radius * _radius;
    public double Perimeter => 2 * Math.PI * _radius;
    public string Color     { get; set; } = "Red";
}

// 抽象クラスで抽象プロパティ
public abstract class Animal
{
    public abstract string Sound { get; }   // 派生クラスで必ず実装

    public void Speak() => Console.WriteLine($"{GetType().Name} says {Sound}");
}

public class Dog : Animal
{
    public override string Sound => "Woof";
}

public class Cat : Animal
{
    public override string Sound => "Meow";
}

IShape c = new Circle(5);
Console.WriteLine(c.Area.ToString("F2")); // 78.54

Animal[] animals = { new Dog(), new Cat() };
foreach (var a in animals) a.Speak();
// Dog says Woof
// Cat says Meow

using System.ComponentModel;
using System.Runtime.CompilerServices;

// 基底クラスに共通実装をまとめる
public abstract class ObservableBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;

    protected void OnPropertyChanged([CallerMemberName] string? name = null)
        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));

    protected bool SetField<T>(ref T field, T value, [CallerMemberName] string? name = null)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return false;
        field = value;
        OnPropertyChanged(name);
        return true;
    }
}

// ViewModel クラス（WPF / MAUI で使う例）
public class PersonViewModel : ObservableBase
{
    private string _name = "";
    private int    _age;

    public string Name
    {
        get => _name;
        set => SetField(ref _name, value);   // 変更があれば PropertyChanged を発火
    }

    public int Age
    {
        get => _age;
        set
        {
            if (SetField(ref _age, value))
                OnPropertyChanged(nameof(IsAdult));   // 連鎖通知
        }
    }

    public bool IsAdult => _age >= 18;   // 計算プロパティも通知できる
}

// 使用例（UI フレームワーク外でのテスト）
var vm = new PersonViewModel();
vm.PropertyChanged += (sender, e)
    => Console.WriteLine($"変更: {e.PropertyName}");

vm.Name = "Taro";  // → 変更: Name
vm.Age  = 20;      // → 変更: Age  / 変更: IsAdult
vm.Age  = 20;      // 値が同じ → 発火しない（SetField が判定）

// 整数インデックスのインデクサー
public class CircularBuffer<T>
{
    private readonly T[] _data;
    private int _size;

    public CircularBuffer(int capacity) => _data = new T[capacity];

    // インデクサー: obj[i] で読み書きできる
    public T this[int index]
    {
        get => _data[index % _data.Length];
        set
        {
            _data[index % _data.Length] = value;
            _size = Math.Min(_size + 1, _data.Length);
        }
    }

    public int Count => _size;
}

var buf = new CircularBuffer<int>(3);
buf[0] = 10;
buf[1] = 20;
buf[2] = 30;
buf[3] = 40;   // 0番地に上書き（循環）
Console.WriteLine(buf[0]); // 40
Console.WriteLine(buf[1]); // 20

// 文字列キーで設定値を取り出す（Dictionary のラッパー例）
public class AppSettings
{
    private readonly Dictionary<string, string> _store = new();

    public string this[string key]
    {
        get => _store.TryGetValue(key, out var v) ? v : "";
        set => _store[key] = value;
    }

    // 複数インデクサー（引数の型が違えば定義可）
    public string this[string section, string key]
    {
        get => _store.TryGetValue($"{section}:{key}", out var v) ? v : "";
        set => _store[$"{section}:{key}"] = value;
    }
}

var settings = new AppSettings();
settings["Theme"] = "Dark";
settings["Database", "Host"] = "localhost";

Console.WriteLine(settings["Theme"]);             // Dark
Console.WriteLine(settings["Database", "Host"]);  // localhost
Console.WriteLine(settings["Missing"]);           // ""（キーなし → 空文字）

using System.Text.Json;
using System.Text.Json.Serialization;

public class SampleData
{
    public string PublicProp { get; set; } = "プロパティ";   // ✓ 対象
    public string PublicField = "フィールド";                // ✗ デフォルト非対象
    private string _privateField = "プライベート";           // ✗ 非対象
}

var data = new SampleData();
string json = JsonSerializer.Serialize(data);
// → {"PublicProp":"プロパティ"}
//   PublicField は含まれない！

// フィールドも対象にしたい場合: JsonSerializerOptions で設定
var options = new JsonSerializerOptions { IncludeFields = true };
string json2 = JsonSerializer.Serialize(data, options);
// → {"PublicProp":"プロパティ","PublicField":"フィールド"}

// 個別に [JsonInclude] でフィールドを対象にできる
public class WithAttribute
{
    [JsonInclude]
    public string IncludedField = "含む";   // [JsonInclude] で明示的に対象化

    [JsonIgnore]
    public string IgnoredProp { get; set; } = "除外";  // プロパティでも除外可
}

using System.Reflection;

public class Product
{
    public string Name     { get; set; } = "Widget";   // プロパティ
    public decimal Price   { get; set; } = 9.99m;      // プロパティ
    public string Category = "Electronics";             // フィールド（public）
}

var product = new Product();
var type    = typeof(Product);

// プロパティの一覧を取得
PropertyInfo[] props = type.GetProperties();
foreach (var p in props)
    Console.WriteLine($"[Prop] {p.Name} = {p.GetValue(product)}");
// [Prop] Name = Widget
// [Prop] Price = 9.99

// フィールドの一覧を取得
FieldInfo[] fields = type.GetFields();
foreach (var f in fields)
    Console.WriteLine($"[Field] {f.Name} = {f.GetValue(product)}");
// [Field] Category = Electronics

// 値のセット
type.GetProperty("Name")?.SetValue(product, "Gadget");
type.GetField("Category")?.SetValue(product, "Tools");

Console.WriteLine(product.Name);     // Gadget
Console.WriteLine(product.Category); // Tools

using System.Threading;

public class ThreadSafeCounter
{
    // パターン1: Interlocked — int/long の加算・交換に最適
    private int _count;
    public int Count => _count;                      // 読み取り
    public void Increment() => Interlocked.Increment(ref _count);
    public void Add(int n)  => Interlocked.Add(ref _count, n);

    // パターン2: lock — 複合操作や参照型に使う
    private readonly object _lock = new();
    private string _status = "Idle";
    public string Status
    {
        get { lock (_lock) return _status; }
        set { lock (_lock) _status = value; }
    }

    // パターン3: volatile — 読み取り/書き込みのみ（加算は非アトミック）
    private volatile bool _isRunning;
    public bool IsRunning
    {
        get => _isRunning;
        set => _isRunning = value;
    }
}

// NG: フィールドを直接公開
public class BadDesign
{
    public int Count;          // 直接変更できてしまう
}

// 後でバリデーションを追加しようとしても…
// 呼び出し側のコードを書き換えなくて済む方法はない（API 破壊）
// Count を読んでいる既存コードがすべて影響を受ける

// OK: 最初からプロパティにしておく
public class GoodDesign
{
    private int _count;
    public int Count
    {
        get => _count;
        set
        {
            if (value < 0) throw new ArgumentOutOfRangeException(nameof(value));
            _count = value;
        }
    }
}
// → 後でバリデーション追加しても呼び出し側コードは変更不要

// struct のプロパティを変更すると暗黙のコピーが発生する
public struct MutablePoint
{
    public int X { get; set; }
    public int Y { get; set; }
}

var point = new MutablePoint { X = 1, Y = 2 };
// OK: 変数に直接代入
point.X = 10;

// NG: コレクション内の struct 変更は元に反映されない
var list = new List<MutablePoint> { point };
// list[0].X = 99;  // CS1612: コピーに対する変更のためエラー

// 解決策1: ローカル変数に取り出して変更して戻す
var tmp = list[0];
tmp.X = 99;
list[0] = tmp;

// 解決策2: struct を readonly にして不変設計にする
public readonly struct ImmutablePoint
{
    public int X { get; init; }
    public int Y { get; init; }
    public ImmutablePoint Move(int dx, int dy) => new() { X = X + dx, Y = Y + dy };
}