[C#] struct を深掘りする — 基本・コンストラクタ・フィールド初期化・readonly・ref struct・IDisposable

struct Point
{
    public int X;
    public int Y;
}

Point p;
p.X = 3;
p.Y = 4;
Console.WriteLine($"({p.X}, {p.Y})"); // (3, 4)

struct Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public double Distance() => Math.Sqrt(X * X + Y * Y);

    public override string ToString() => $"({X}, {Y})";
}

Point p = new Point { X = 3, Y = 4 };
Console.WriteLine(p.Distance()); // 5
Console.WriteLine(p);            // (3, 4)

interface ITranslatable
{
    void Translate(int dx, int dy);
}

struct Point : ITranslatable
{
    public int X { get; set; }
    public int Y { get; set; }

    public void Translate(int dx, int dy)
    {
        X += dx;
        Y += dy;
    }
}

struct Point
{
    public int X;
    public int Y;

    // C# 1.0 〜 9 でも可：パラメーターありコンストラクタ
    public Point(int x, int y)
    {
        X = x;
        Y = y; // すべてのフィールドを初期化しないとエラー
    }
}

struct Counter
{
    public int Value;

    // C# 10 から定義可能
    public Counter()
    {
        Value = 1; // 好きな初期値を設定できる
    }
}

var c = new Counter();
Console.WriteLine(c.Value); // 1

Counter d = default;
Console.WriteLine(d.Value); // 0（コンストラクタは呼ばれない）

struct Config
{
    public required string Host { get; init; }
    public required int    Port { get; init; }
}

// コンパイルエラーになる（required メンバーが未設定）
// Config c = new Config();

// OK
Config c = new Config { Host = "localhost", Port = 8080 };

// C# 10 以降
struct Gauge
{
    public int Min = 0;    // フィールド初期化子
    public int Max = 100;  // フィールド初期化子
    public int Value = 50; // フィールド初期化子
}

var g = new Gauge();
Console.WriteLine(g.Value); // 50

Gauge d = default;
Console.WriteLine(d.Value); // 0（初期化子は実行されない）

struct Gauge
{
    public int Min   = 0;
    public int Max   = 100;
    public int Value = 50;

    public Gauge() { } // パラメーターなしコンストラクタを明示
}

var g = new Gauge();
Console.WriteLine(g.Value); // 50（初期化子が実行される）

readonly struct ImmutablePoint
{
    public int X { get; }
    public int Y { get; }

    public ImmutablePoint(int x, int y)
    {
        X = x;
        Y = y;
    }

    public ImmutablePoint Translate(int dx, int dy)
        => new ImmutablePoint(X + dx, Y + dy);
}

// readonly struct ならコンパイラが防御コピーを生成しない
void Print(in ImmutablePoint p)
{
    Console.WriteLine($"({p.X}, {p.Y})");
}

struct Rectangle
{
    public int Width;
    public int Height;

    // このメソッドは this を変更しないことをコンパイラに伝える
    public readonly int Area() => Width * Height;

    // このプロパティも読み取り専用
    public readonly string Description => $"{Width}x{Height}";
}

struct Rectangle
{
    public int Width;
    public int Height;

    public readonly void Reset()
    {
        Width = 0; // エラー：readonly メンバーで this のフィールドを変更できない
    }
}

ref struct SpanLike
{
    private ref int _first;
    // ...
}

int[] array = { 1, 2, 3, 4, 5 };
Span<int> span = array.AsSpan(1, 3); // index 1〜3 のスライス

foreach (int v in span)
    Console.Write($"{v} "); // 2 3 4

class Container
{
    // コンパイルエラー：ref struct はフィールドにできない
    // Span<int> _span;
}

ref struct RentedBuffer
{
    private int[] _buffer;
    private readonly int _length;

    public RentedBuffer(int length)
    {
        _buffer = System.Buffers.ArrayPool<int>.Shared.Rent(length);
        _length = length;
    }

    public Span<int> AsSpan() => _buffer.AsSpan(0, _length);

    // IDisposable は実装できないが、Dispose() メソッドは定義できる
    public void Dispose()
    {
        if (_buffer is not null)
        {
            System.Buffers.ArrayPool<int>.Shared.Return(_buffer);
            _buffer = null!;
        }
    }
}

using var buf = new RentedBuffer(256);
Span<int> span = buf.AsSpan();
// ... span を操作 ...
// ブロックを抜けると自動で Dispose() が呼ばれる

// C# 13
ref struct MySpan<T> : IDisposable
{
    // ...

    public void Dispose()
    {
        // クリーンアップ処理
    }
}

// T に ref struct を渡せる
void Process<T>(T value) where T : allows ref struct, IDisposable
{
    using (value)
    {
        // ...
    }
}