【C#】値型と参照型完全ガイド｜スタック・ヒープ・boxing・ref引数・コピー・string不変性まで

void ExampleMethod()
{
    // ─── スタックに配置される ──────────────────────
    int x = 10;          // int 値そのものがスタック上
    double pi = 3.14;    // double 値そのものがスタック上

    // ─── ヒープに配置される ────────────────────────
    var list = new List<int>(); // リスト本体はヒープ
    // list 変数（スタック）にはヒープ上のアドレスが入っている

    // ─── struct はスタック（ローカル変数の場合）────
    DateTime now = DateTime.Now;   // DateTime (struct) はスタック上
    // ただし class のフィールドになると struct もヒープ上に配置される

    // ─── メソッドが終わるとスタックは自動解放 ──────
} // ここで x, pi, list の「参照」はスタックから消える
  // ただし list が指すヒープ上のオブジェクトは GC が回収するまで残る

// ─── 値型：代入はコピーを作る ──────────────────────
int a = 10;
int b = a;   // b に a の「値」がコピーされる
b = 20;
Console.WriteLine(a); // 10（a は不変）
Console.WriteLine(b); // 20

// struct も同様
DateTime d1 = new DateTime(2025, 1, 1);
DateTime d2 = d1; // 値全体がコピーされる
// d2 を変更しても d1 に影響しない

// ─── 参照型：代入は参照（アドレス）をコピー ────────
class Counter { public int Value; }

var c1 = new Counter { Value = 0 };
var c2 = c1; // c2 は c1 と同じオブジェクトを指す！
c2.Value = 99;
Console.WriteLine(c1.Value); // 99（c1 も変わる！）
Console.WriteLine(c2.Value); // 99

// ─── null の扱いの違い ────────────────────────────
int x = 0;       // 値型のデフォルトは 0
// int y = null; // コンパイルエラー（値型に null は代入不可）

string s = null; // 参照型は null を保持できる（何も指さない状態）
Counter c = null;// クラスも null OK

// ─── 値型の == は値の比較 ─────────────────────────
int x = 5, y = 5;
Console.WriteLine(x == y);        // true（値が同じ）
Console.WriteLine(x.Equals(y));   // true

DateTime d1 = new DateTime(2025, 1, 1);
DateTime d2 = new DateTime(2025, 1, 1);
Console.WriteLine(d1 == d2);   // true（同じ日付）

// ─── 参照型の == はデフォルトで「参照の一致」を比較 ──
class Box { public int Value; }

var b1 = new Box { Value = 10 };
var b2 = new Box { Value = 10 };
var b3 = b1; // 同じ参照

Console.WriteLine(b1 == b2);      // false（異なるオブジェクト）
Console.WriteLine(b1 == b3);      // true（同じオブジェクト）
Console.WriteLine(b1.Equals(b2)); // false（Equals もデフォルトは参照比較）

// ─── Equals をオーバーライドすると値比較できる ──────
// 5838（クラスとオブジェクト）記事で詳解

// ─── record は値比較がデフォルト ─────────────────
record Point(int X, int Y);

var p1 = new Point(1, 2);
var p2 = new Point(1, 2);
Console.WriteLine(p1 == p2);   // true（record は値比較）

// ─── string は参照型だが == は値（文字列内容）を比較 ──
string s1 = "hello";
string s2 = "hello";
Console.WriteLine(s1 == s2);          // true（内容が同じ）
Console.WriteLine(ReferenceEquals(s1, s2)); // true（インターニングにより同一参照）

string s3 = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
Console.WriteLine(s1 == s3);          // true（内容比較）
Console.WriteLine(ReferenceEquals(s1, s3)); // false（異なるオブジェクト）

// ─── 通常（値渡し）: 呼び出し元に変更が反映されない ──
void AddTen(int n) => n += 10;
int v = 5;
AddTen(v);
Console.WriteLine(v); // 5（変わらない）

// ─── ref: 参照渡し（読み書き両方可能） ──────────────
void AddTenRef(ref int n) => n += 10;
int v2 = 5;
AddTenRef(ref v2);
Console.WriteLine(v2); // 15（呼び出し元が変わる）

// ref は呼び出し前に初期化が必要
// AddTenRef(ref uninitializedVar); // コンパイルエラー

// ─── out: 戻り値の出力用（初期化は不要・メソッド内で必ず代入）
bool TryParse(string s, out int result)
{
    if (int.TryParse(s, out result)) return true;
    result = 0; // out は必ずメソッド内で代入する義務がある
    return false;
}
if (TryParse("42", out int parsed))
    Console.WriteLine(parsed); // 42

// C# 7+: インライン宣言
if (int.TryParse("100", out int n3))
    Console.WriteLine(n3); // 100

// ─── in: 読み取り専用参照（コピーを避けつつ変更不可）──
// 大きな struct のコピーコストを避けたいとき
readonly struct BigStruct { /* 多数のフィールド */ }

void ReadOnly(in BigStruct s)
{
    // s.X = 10; // コンパイルエラー（変更できない）
    Console.WriteLine(s.GetHashCode()); // 読み取りのみ
}

// ─── ref 戻り値: メモリ上の値を直接返す（高度な最適化）
ref int GetRef(int[] arr, int index) => ref arr[index];
int[] data = { 1, 2, 3 };
ref int elem = ref GetRef(data, 1);
elem = 99;
Console.WriteLine(data[1]); // 99（配列の要素を直接変更）

// ─── boxing: int → object への暗黙変換 ────────────
int value = 42;
object boxed = value; // boxing：ヒープに新しいオブジェクトが作られる

// ─── unboxing: object → int への明示キャスト ────────
int unboxed = (int)boxed; // unboxing：値を取り出してスタックにコピー

// ─── よくある boxing 発生場面 ─────────────────────
// 1. ArrayList（非ジェネリック）への追加
var list = new System.Collections.ArrayList();
list.Add(42);    // boxing（int → object）
int n = (int)list[0]; // unboxing

// 2. object 型の変数への代入
object obj = DateTime.Now; // boxing

// 3. string.Format の {0} 引数
string s = string.Format("{0}", 123); // boxing 発生
// GOOD: 文字列補間は boxing を避けられる場合がある
string s2 = $"{123}"; // boxing なし（コンパイラが最適化）

// 4. ジェネリックでない IComparable
void Sort(System.Collections.IList items) { /* boxing 多発 */ }

// ─── boxing を避ける方法 ──────────────────────────
// GOOD: ジェネリックを使う（boxing しない）
var genericList = new List<int>();
genericList.Add(42); // boxing なし
int m = genericList[0]; // unboxing なし

// ─── 不変性: string の「変更」は常に新しいオブジェクトを生成 ──
string s1 = "hello";
string s2 = s1;         // 参照コピー（同じオブジェクトを指す）
s1 = s1.ToUpper();      // "HELLO" という新しいオブジェクトを作り s1 に代入
Console.WriteLine(s1);  // HELLO
Console.WriteLine(s2);  // hello（s2 は元のオブジェクトをそのまま参照）

// ← 参照型なのに s2 が影響を受けないのは string が immutable だから

// ─── 文字列インターニング（interning）────────────────
// リテラル文字列は同じ内容なら同一オブジェクトを共有（メモリ効率化）
string a = "hello";
string b = "hello";
Console.WriteLine(ReferenceEquals(a, b)); // true（同一オブジェクト）

// new でインターニングを回避
string c = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
Console.WriteLine(ReferenceEquals(a, c)); // false（別オブジェクト）
Console.WriteLine(a == c);               // true（内容は同じ）

// ─── string の == は内容比較（== をオーバーロードしている）──
Console.WriteLine("abc" == "abc"); // true

// ─── StringBuilder: 大量の文字列結合には必須 ────────
// BAD: += はループのたびに新しい string を生成 → O(n²) のコスト
string result = "";
for (int i = 0; i < 10000; i++)
    result += i.ToString(); // 毎回コピー

// GOOD: StringBuilder で一気に構築してから ToString()
var sb = new System.Text.StringBuilder();
for (int i = 0; i < 10000; i++)
    sb.Append(i);
string result2 = sb.ToString(); // 1回だけ string 生成

class Address
{
    public string City { get; set; } = "";
}

class Person
{
    public string Name { get; set; } = "";
    public Address Address { get; set; } = new();

    // 浅いコピー: MemberwiseClone() は protected なので public にラップ
    public Person ShallowCopy() => (Person)MemberwiseClone();

    // 深いコピー: ネストしたオブジェクトも新しく作る
    public Person DeepCopy() => new Person
    {
        Name    = this.Name,
        Address = new Address { City = this.Address.City }
    };
}

var original = new Person { Name = "Alice", Address = new Address { City = "Tokyo" } };

// ─── 浅いコピー ────────────────────────────────────
var shallow = original.ShallowCopy();
shallow.Name = "Bob";                // Name は独立してコピーされている
shallow.Address.City = "Osaka";     // Address は共有されている！

Console.WriteLine(original.Name);         // Alice（独立）
Console.WriteLine(original.Address.City); // Osaka ← 元のデータが変わった！

// ─── 深いコピー ────────────────────────────────────
var original2 = new Person { Name = "Alice", Address = new Address { City = "Tokyo" } };
var deep = original2.DeepCopy();
deep.Address.City = "Sapporo";

Console.WriteLine(original2.Address.City); // Tokyo（影響なし）

// BAD: 可変 struct は直感に反する動作になりやすい
struct MutablePoint { public int X; public int Y; }

MutablePoint p = new MutablePoint { X = 1, Y = 2 };
var copy = p;  // 値型なのでコピー
copy.X = 99;
Console.WriteLine(p.X); // 1（影響なし → 意図どおり）

// しかし LINQ や foreach で予期しない挙動になることがある

// GOOD: readonly struct で不変性を保証する（C# 7.2+）
readonly struct Point
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
    public Point Translate(int dx, int dy) => new(X + dx, Y + dy); // 新しいインスタンスを返す
    public override string ToString() => $"({X}, {Y})";
}

var pt = new Point(1, 2);
var moved = pt.Translate(3, 4);
Console.WriteLine(pt);    // (1, 2)（不変）
Console.WriteLine(moved); // (4, 6)

// ─── 値オブジェクトの実例 ────────────────────────
readonly struct Money
{
    public decimal Amount { get; }
    public string Currency { get; }
    public Money(decimal amount, string currency) { Amount = amount; Currency = currency; }
    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(1000, "JPY");
var tax    = new Money(100, "JPY");
var total  = price.Add(tax);
Console.WriteLine(total); // 1,100 JPY

// Span<T> は配列・文字列・スタック領域を同一 API で扱える ref struct
int[] array = { 1, 2, 3, 4, 5 };

// ─── 配列の一部を参照（コピーなし）──────────────
Span<int> span = array.AsSpan(1, 3); // インデックス1〜3の3要素
span[0] = 99;
Console.WriteLine(array[1]); // 99（Span は配列を直接参照）

// ─── 文字列を substring なしで参照 ──────────────
string text = "2025-08-28";
ReadOnlySpan<char> year  = text.AsSpan(0, 4); // "2025"（コピーなし）
ReadOnlySpan<char> month = text.AsSpan(5, 2); // "08"（コピーなし）

// ─── stackalloc でスタックにバッファを確保 ────────
Span<byte> buffer = stackalloc byte[256]; // ヒープ割り当てなし
buffer[0] = 0xFF;

// ref struct の制約: クラスのフィールドにできない・async メソッドでは使えない

// ─── 落とし穴 1: struct を LINQ で変更しようとする ──
struct Counter { public int Value; }

var counters = new List<Counter> { new Counter { Value = 0 } };
// foreach は コピー を返すため、コピーに対して操作している
// counters[0].Value++; // これはコンパイルエラー（直接変更はできない）

// GOOD: インデックスでアクセスして代入
// counters[0] = new Counter { Value = counters[0].Value + 1 };

// ─── 落とし穴 2: 参照型でも「再代入」は呼び元に影響しない ──────────
// string に限らず、参照型を値渡しすると「参照のコピー」が渡される
// ローカル変数 s を新しいオブジェクトに向け直しても、呼び元の text は変わらない
void ReassignString(string s) => s = "new value"; // s を別のオブジェクトに向けるだけ
string text = "original";
ReassignString(text);
Console.WriteLine(text); // "original"（呼び元の text は変わらない）
// ※ string の不変性の話ではなく「参照渡し vs 値渡し」の話

// 呼び元の参照そのものを変えたいなら ref を使う
void ReassignStringRef(ref string s) => s = "new value";
ReassignStringRef(ref text);
Console.WriteLine(text); // "new value"

// ─── 落とし穴 3: Dictionary の struct 値を変更できない ──
var dict = new Dictionary<string, Counter>();
dict["key"] = new Counter { Value = 0 };
// dict["key"].Value++; // コンパイルエラー: インデクサーの戻り値は右辺値

// GOOD: 取り出して変更して代入
var c = dict["key"];
c.Value++;
dict["key"] = c;

// または class に変えて参照のまま変更