クラス

【C#】構造体コピーを完全攻略：浅いコピーと深いコピーの違いと安全な実装術

2025-05-07更新日: 2025-05-07

C#の構造体は値型なので代入やメソッド引数で丸ごとコピーされ、コピー後は互いに独立です。

ただしフィールドに参照型を含む場合は参照先を共有するため、深い複製が必要なら手動で新しいインスタンスを作成する必要があります。

サイズが大きい構造体はin引数やreadonly指定でコピー回数を抑えるとメモリ効率が向上します。

目次から探す

構造体コピーの基礎知識
代入とメソッド呼び出しで起こるコピー
- 変数間の代入
- メソッド引数・戻り値
浅いコピー
- 自動生成されるビット単位コピー
- 参照型フィールドを含む場合の挙動
深いコピー
readonly構造体による防御策
言語機能を活かした最適化
実装サンプルカタログ
パフォーマンス計測と最適化
テスト観点
- 同値性と同一性の検証
- 参照分離を保証するユニットテスト
シリアライズを利用したコピー応用
- JSONシリアライズによる一時的ディープコピー
- BinaryFormatter廃止と代替手段
自動生成による効率化
- Source GeneratorでのCloneコード生成
- IL Weavingツールの導入可否
よくある落とし穴
他言語との比較で理解を深める
- C++のstructとのコピー挙動差
- RustのCopyトレイトとの対比
まとめ

構造体コピーの基礎知識

C#の構造体structは値型であり、コピーの挙動がクラス(参照型)とは大きく異なります。

ここでは、構造体コピーの基本的な特徴や、クラスとの違い、コピーが発生する具体的なタイミングについて詳しく解説します。

値型としての特徴

構造体は値型であるため、変数に代入したりメソッドに渡したりするときに、その値が丸ごとコピーされます。

これは、構造体のインスタンスがメモリ上に直接データとして存在し、変数間で値の複製が行われることを意味します。

例えば、以下のような構造体Pointを考えてみましょう。

public struct Point
{
    public double X { get; set; }
    public double Y { get; set; }
    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }
}
class Program
{
    static void Main()
    {
        Point p1 = new Point(1.0, 2.0);
        Point p2 = p1; // p1の値がp2にコピーされる
        p2.X = 10.0; // p2の変更はp1に影響しない
        Console.WriteLine($"p1: X={p1.X}, Y={p1.Y}");
        Console.WriteLine($"p2: X={p2.X}, Y={p2.Y}");
    }
}

p1: X=1, Y=2
p2: X=10, Y=2

この例では、p1の値がp2にコピーされているため、p2.Xを変更してもp1.Xには影響がありません。

これは値型の基本的な特徴であり、構造体のコピーが「独立した別の値」として扱われることを示しています。

値型の特徴として、以下のポイントが挙げられます。

メモリ上に直接データが格納される
代入やメソッド呼び出し時に値のコピーが発生する
コピーされた値は元の値と独立している
参照型のようにヒープ上のオブジェクトを指す参照ではない

このため、構造体は小さくて不変なデータを表現するのに適しています。

ただし、構造体のサイズが大きくなるとコピーコストが増えるため、設計時に注意が必要です。

クラスとのメモリ配置の違い

C#のクラスは参照型であり、インスタンスはヒープ上に確保されます。

変数はヒープ上のオブジェクトを指す参照(ポインタのようなもの)を保持します。

代入やメソッド呼び出し時には、この参照がコピーされるだけで、実際のオブジェクトは共有されます。

一方、構造体は値型であり、変数はスタックやフィールドの中に直接データを保持します。

代入やメソッド呼び出し時には、データそのものがコピーされます。

以下の表にクラスと構造体のメモリ配置の違いをまとめます。

項目	クラス(参照型)	構造体(値型)
メモリ配置	ヒープ上にインスタンスを確保	スタックやフィールドに直接データを保持
変数の中身	オブジェクトの参照(ポインタ)	実際のデータ
代入時の挙動	参照のコピー(同じオブジェクトを指す)	データのコピー(独立した値になる)
ガベージコレクション	ヒープ上のオブジェクトを管理	不要(スタック上のため自動解放)

この違いにより、クラスの変数を代入すると複数の変数が同じオブジェクトを参照するため、片方の変更がもう片方に影響します。

一方、構造体はコピーされるため、変更は独立しています。

コピーが発生するタイミング

構造体のコピーは、以下のような場面で自動的に発生します。

変数間の代入

構造体のインスタンスを別の変数に代入するとき、値がコピーされます。

Point p1 = new Point(3.0, 4.0);
Point p2 = p1; // p1の値がp2にコピーされる

このとき、p2はp1の独立したコピーとなり、以降の変更は互いに影響しません。

メソッドの引数渡し

構造体をメソッドの引数として渡す場合、デフォルトでは値渡し(コピー)が行われます。

void MovePoint(Point p)
{
    p.X += 1.0;
    p.Y += 1.0;
}
Point p = new Point(5.0, 6.0);
MovePoint(p);
Console.WriteLine($"p: X={p.X}, Y={p.Y}"); // 元のpは変わらない

p: X=5, Y=6

この例では、MovePointに渡されたpはコピーであり、メソッド内の変更は呼び出し元に影響しません。

ただし、refやout修飾子を使うと参照渡しとなり、コピーは発生しません。

void MovePointRef(ref Point p)
{
    p.X += 1.0;
    p.Y += 1.0;
}
Point p = new Point(5.0, 6.0);
MovePointRef(ref p);
Console.WriteLine($"p: X={p.X}, Y={p.Y}"); // 変更が反映される

p: X=6, Y=7

メソッドの戻り値

構造体をメソッドの戻り値として返す場合も、値がコピーされます。

Point CreatePoint()
{
    return new Point(7.0, 8.0);
}
Point p = CreatePoint(); // 戻り値のコピーがpに代入される

プロパティの取得

構造体をプロパティとして持つ場合、プロパティのゲッターを呼び出すとコピーが発生します。

public struct Container
{
    public Point PointValue { get; set; }
}
Container c = new Container { PointValue = new Point(1.0, 2.0) };
Point p = c.PointValue; // コピーされる

このコピーは意図しない副作用を生むことがあるため、注意が必要です。

以上のように、構造体は値型であるため、代入やメソッド呼び出し時に自動的にコピーが発生します。

コピーはデータの独立性を保つ一方で、参照型のメンバーを持つ構造体では浅いコピーとなり、参照先の共有が起こるため注意が必要です。

代入とメソッド呼び出しで起こるコピー

変数間の代入

構造体は値型であるため、変数間で代入を行うときにデータのコピーが発生します。

これは、代入先の変数に元の構造体の値が丸ごと複製されることを意味します。

以下の例をご覧ください。

public struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}
class Program
{
    static void Main()
    {
        Point p1 = new Point(10, 20);
        Point p2 = p1; // p1の値がp2にコピーされる
        p2.X = 100; // p2の変更はp1に影響しない
        Console.WriteLine($"p1: X={p1.X}, Y={p1.Y}");
        Console.WriteLine($"p2: X={p2.X}, Y={p2.Y}");
    }
}

p1: X=10, Y=20
p2: X=100, Y=20

この例では、p1の値がp2にコピーされているため、p2.Xを変更してもp1.Xは変わりません。

代入時にコピーが発生するため、両者は独立した別の値として扱われます。

ただし、構造体のメンバーに参照型が含まれている場合は注意が必要です。

参照型のフィールドはコピーされるのではなく、参照がコピーされるため、参照先のオブジェクトは共有されます。

public struct SampleStruct
{
    public int[] Numbers;
    public SampleStruct(int[] numbers)
    {
        Numbers = numbers;
    }
}
class Program
{
    static void Main()
    {
        int[] arr = { 1, 2, 3 };
        SampleStruct s1 = new SampleStruct(arr);
        SampleStruct s2 = s1; // Numbersの参照がコピーされる
        s2.Numbers[0] = 100; // s1.Numbersも変更される
        Console.WriteLine($"s1.Numbers[0]: {s1.Numbers[0]}");
        Console.WriteLine($"s2.Numbers[0]: {s2.Numbers[0]}");
    }
}

s1.Numbers[0]: 100
s2.Numbers[0]: 100

このように、参照型のフィールドは浅いコピーとなり、参照先のデータは共有されます。

これが意図しない副作用を生むことがあるため、深いコピーが必要な場合は別途対応が必要です。

メソッド引数・戻り値

構造体をメソッドの引数として渡す場合、デフォルトでは値渡しとなり、引数のコピーが作成されます。

メソッド内で引数の値を変更しても、呼び出し元の変数には影響しません。

public struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}
class Program
{
    static void ModifyPoint(Point p)
    {
        p.X = 999; // コピーの値を変更
    }
    static void Main()
    {
        Point p = new Point(1, 2);
        ModifyPoint(p);
        Console.WriteLine($"p: X={p.X}, Y={p.Y}"); // 変更されていない
    }
}

p: X=1, Y=2

この例では、ModifyPointに渡されたpはコピーであり、メソッド内の変更は呼び出し元に反映されません。

一方、メソッドの戻り値として構造体を返す場合も、戻り値のコピーが作成されます。

public struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}
class Program
{
    static Point CreatePoint()
    {
        return new Point(5, 6);
    }
    static void Main()
    {
        Point p = CreatePoint(); // 戻り値のコピーがpに代入される
        Console.WriteLine($"p: X={p.X}, Y={p.Y}");
    }
}

p: X=5, Y=6

in/ref/out 修飾子の影響

C#では、メソッドの引数にin、ref、outの修飾子を付けることで、構造体のコピー挙動を制御できます。

修飾子	コピーの有無	説明
なし	コピーあり	値渡し。引数のコピーが作成されます。
`in`	コピーなし	読み取り専用の参照渡し。コピーを避けます。
`ref`	コピーなし	参照渡し。読み書き可能です。
`out`	コピーなし	参照渡し。初期化が必須。

in修飾子はC# 7.2で導入され、構造体のコピーを避けつつ読み取り専用で渡せるため、パフォーマンス向上に役立ちます。

以下にそれぞれの例を示します。

in修飾子の例

public struct LargeStruct
{
    public int A, B, C, D, E;
    public void Display()
    {
        Console.WriteLine($"A={A}, B={B}, C={C}, D={D}, E={E}");
    }
}
class Program
{
    static void PrintLargeStruct(in LargeStruct ls)
    {
        // lsは読み取り専用。変更不可。
        ls.Display();
    }
    static void Main()
    {
        LargeStruct ls = new LargeStruct { A = 1, B = 2, C = 3, D = 4, E = 5 };
        PrintLargeStruct(ls);
    }
}

A=1, B=2, C=3, D=4, E=5

inを使うことで、引数のコピーを避けて参照渡ししつつ、メソッド内での変更を防止できます。

ref修飾子の例

public struct Point
{
    public int X;
    public int Y;
}
class Program
{
    static void ModifyPoint(ref Point p)
    {
        p.X = 50;
        p.Y = 60;
    }
    static void Main()
    {
        Point p = new Point { X = 10, Y = 20 };
        ModifyPoint(ref p);
        Console.WriteLine($"p: X={p.X}, Y={p.Y}"); // 変更が反映される
    }
}

p: X=50, Y=60

refを使うと、引数は参照渡しとなり、メソッド内の変更が呼び出し元に反映されます。

out修飾子の例

public struct Point
{
    public int X;
    public int Y;
}
class Program
{
    static void InitializePoint(out Point p)
    {
        p = new Point { X = 100, Y = 200 };
    }
    static void Main()
    {
        Point p;
        InitializePoint(out p);
        Console.WriteLine($"p: X={p.X}, Y={p.Y}"); // 初期化されている
    }
}

p: X=100, Y=200

outは参照渡しで、メソッド内で必ず初期化しなければなりません。

このように、構造体のコピーは代入やメソッド呼び出し時に自動的に発生しますが、in、ref、out修飾子を使うことでコピーを抑制し、パフォーマンスや動作を制御できます。

特に大きな構造体を扱う場合は、これらの修飾子を適切に使うことが重要です。

浅いコピー

自動生成されるビット単位コピー

C#の構造体は値型であり、代入やメソッド呼び出し時に自動的にコピーが行われます。

このコピーは「浅いコピー(shallow copy)」として実装されており、構造体の全フィールドのビット単位での複製が行われます。

つまり、構造体のメンバーがプリミティブ型であれば、その値がそのままコピーされます。

例えば、以下のような単純な構造体を考えます。

public struct SimpleStruct
{
    public int Number;
    public double Value;
    public SimpleStruct(int number, double value)
    {
        Number = number;
        Value = value;
    }
}
class Program
{
    static void Main()
    {
        SimpleStruct s1 = new SimpleStruct(10, 3.14);
        SimpleStruct s2 = s1; // 浅いコピー(ビット単位コピー)
        s2.Number = 20;
        Console.WriteLine($"s1.Number = {s1.Number}, s1.Value = {s1.Value}");
        Console.WriteLine($"s2.Number = {s2.Number}, s2.Value = {s2.Value}");
    }
}

s1.Number = 10, s1.Value = 3.14
s2.Number = 20, s2.Value = 3.14

この例では、s1の値がs2にビット単位でコピーされているため、s2.Numberを変更してもs1.Numberには影響がありません。

プリミティブ型のフィールドは完全に独立したコピーが作成されます。

このビット単位コピーは、C#のコンパイラが自動的に生成するため、特別なコードを書く必要はありません。

構造体の代入やメソッド呼び出し時にこのコピーが行われます。

参照型フィールドを含む場合の挙動

構造体のメンバーに参照型(例えば、配列やクラスのインスタンス)が含まれている場合、浅いコピーは参照のコピーにとどまります。

つまり、参照型フィールドのポインタ(参照)がコピーされるだけで、参照先のオブジェクト自体は共有されます。

以下の例をご覧ください。

public struct StructWithReference
{
    public int Id;
    public int[] Data;
    public StructWithReference(int id, int[] data)
    {
        Id = id;
        Data = data;
    }
}
class Program
{
    static void Main()
    {
        int[] array = { 1, 2, 3 };
        StructWithReference s1 = new StructWithReference(1, array);
        StructWithReference s2 = s1; // 浅いコピー(参照のコピー)
        s2.Data[0] = 100; // 参照先の配列を変更
        Console.WriteLine($"s1.Data[0] = {s1.Data[0]}");
        Console.WriteLine($"s2.Data[0] = {s2.Data[0]}");
    }
}

s1.Data[0] = 100
s2.Data[0] = 100

この例では、s1とs2のDataフィールドは同じ配列を参照しているため、s2.Data[0]を変更するとs1.Data[0]にも影響が及びます。

浅いコピーは参照型の中身までは複製しないため、このような共有が発生します。

共有参照による副作用

参照型フィールドを持つ構造体の浅いコピーは、共有参照による副作用を引き起こすことがあります。

具体的には、コピーした構造体の参照型フィールドを通じてデータを変更すると、元の構造体のデータも変わってしまいます。

この副作用は、以下のような問題を招くことがあります。

予期しないデータの変更が発生し、バグの原因になる
複数の構造体が同じデータを共有しているため、状態管理が複雑になる
スレッドセーフでない共有データの競合が起こる可能性がある

例えば、ゲーム開発やUIプログラミングで構造体を使う場合、参照型フィールドの共有は意図しない挙動を生みやすいです。

イミュータブル設計での回避

共有参照による副作用を防ぐための一つの方法は、構造体をイミュータブル(不変)に設計することです。

イミュータブルな構造体は、作成後に状態が変わらないため、共有参照があってもデータの変更が起こりません。

イミュータブル設計のポイントは以下の通りです。

フィールドをreadonlyにする
プロパティのセッターを持たない(読み取り専用)
参照型フィールドもイミュータブルな型を使う(例：stringや読み取り専用コレクション)
変更が必要な場合は新しいインスタンスを生成する

以下はイミュータブルな構造体の例です。

public struct ImmutableStruct
{
    public readonly int Id;
    public readonly string Name;
    public ImmutableStruct(int id, string name)
    {
        Id = id;
        Name = name;
    }
}
class Program
{
    static void Main()
    {
        ImmutableStruct s1 = new ImmutableStruct(1, "Alice");
        ImmutableStruct s2 = s1; // 浅いコピーでも安全
        // s2.Name = "Bob"; // コンパイルエラー：readonlyなので変更不可
        Console.WriteLine($"s1.Name = {s1.Name}");
        Console.WriteLine($"s2.Name = {s2.Name}");
    }
}

s1.Name = Alice
s2.Name = Alice

このようにイミュータブル設計により、浅いコピーでも共有参照による副作用を防げます。

特に参照型フィールドがイミュータブルであれば、コピーしても安全に使えます。

ただし、イミュータブル設計はすべてのケースで適用できるわけではなく、パフォーマンスや使い勝手の面でトレードオフがあります。

状況に応じて適切な設計を選択してください。

深いコピー

コピーコンストラクタ実装パターン

構造体の深いコピーを実現する代表的な方法の一つがコピーコンストラクタの実装です。

コピーコンストラクタとは、同じ型の別のインスタンスを引数に取り、その内容を新しいインスタンスに複製するコンストラクタのことです。

これにより、参照型フィールドも個別にコピーし、元の構造体と独立した状態を作り出せます。

プリミティブ型と参照型の混在

構造体のフィールドにプリミティブ型(intやdoubleなど)と参照型(配列やクラスのインスタンス)が混在している場合、コピーコンストラクタ内でプリミティブ型は単純に代入し、参照型は新しいインスタンスを生成してコピーする必要があります。

以下はコピーコンストラクタを使った例です。

public struct SampleStruct
{
    public int Id;
    public string Name;
    public int[] Scores;
    // コピーコンストラクタ
    public SampleStruct(SampleStruct other)
    {
        Id = other.Id;               // プリミティブ型は単純代入
        Name = other.Name;           // stringはイミュータブルなので参照コピーで問題ない
        Scores = (int[])other.Scores.Clone(); // 配列はCloneで深いコピー
    }
}
class Program
{
    static void Main()
    {
        SampleStruct s1 = new SampleStruct
        {
            Id = 1,
            Name = "Alice",
            Scores = new int[] { 90, 80, 70 }
        };
        SampleStruct s2 = new SampleStruct(s1); // コピーコンストラクタで深いコピー
        s2.Scores[0] = 100; // s1のScoresには影響しない
        Console.WriteLine($"s1.Scores[0] = {s1.Scores[0]}");
        Console.WriteLine($"s2.Scores[0] = {s2.Scores[0]}");
    }
}

s1.Scores[0] = 90
s2.Scores[0] = 100

この例では、Scores配列をCloneメソッドで複製しているため、s2の変更がs1に影響しません。

Nameはstring型でイミュータブルなので、参照を共有しても安全です。

Clone メソッドの採用ケース

Cloneメソッドを使う方法も深いコピーの実装でよく使われます。

特に、構造体が複雑な参照型フィールドを持つ場合や、コピー処理を明示的に呼び出したい場合に便利です。

ICloneableインターフェースを実装してCloneメソッドを定義することもありますが、ICloneableは戻り値の型がobjectであるため、型安全性の観点からは独自のCloneメソッドを用意するケースが多いです。

以下はCloneメソッドを使った例です。

public struct SampleStruct
{
    public int Id;
    public string Name;
    public int[] Scores;
    public SampleStruct Clone()
    {
        return new SampleStruct
        {
            Id = this.Id,
            Name = this.Name,
            Scores = (int[])this.Scores.Clone()
        };
    }
}
class Program
{
    static void Main()
    {
        SampleStruct s1 = new SampleStruct
        {
            Id = 2,
            Name = "Bob",
            Scores = new int[] { 85, 75, 65 }
        };
        SampleStruct s2 = s1.Clone();
        s2.Scores[1] = 99;
        Console.WriteLine($"s1.Scores[1] = {s1.Scores[1]}");
        Console.WriteLine($"s2.Scores[1] = {s2.Scores[1]}");
    }
}

s1.Scores[1] = 75
s2.Scores[1] = 99

Cloneメソッドを使うことで、呼び出し側が明示的にコピー処理を行うことができ、柔軟に深いコピーを制御できます。

配列・コレクションの再帰的コピー

構造体の参照型フィールドに配列やコレクションが含まれている場合、単純にCloneメソッドを呼ぶだけでは不十分なことがあります。

特に、配列やコレクションの要素自体が参照型である場合は、要素ごとに再帰的にコピーを行う必要があります。

例えば、int[]のようなプリミティブ型配列はCloneで十分ですが、List<SampleClass>のようなコレクションの場合は、各要素のコピーも考慮しなければなりません。

以下は再帰的コピーのイメージです。

public class SampleClass
{
    public int Value;
    public SampleClass(int value)
    {
        Value = value;
    }
    public SampleClass DeepCopy()
    {
        return new SampleClass(Value);
    }
}
public struct StructWithList
{
    public List<SampleClass> Items;
    public StructWithList(List<SampleClass> items)
    {
        Items = items;
    }
    public StructWithList DeepCopy()
    {
        var newList = new List<SampleClass>(Items.Count);
        foreach (var item in Items)
        {
            newList.Add(item.DeepCopy());
        }
        return new StructWithList(newList);
    }
}
class Program
{
    static void Main()
    {
        var list = new List<SampleClass> { new SampleClass(1), new SampleClass(2) };
        StructWithList s1 = new StructWithList(list);
        StructWithList s2 = s1.DeepCopy();
        s2.Items[0].Value = 100;
        Console.WriteLine($"s1.Items[0].Value = {s1.Items[0].Value}");
        Console.WriteLine($"s2.Items[0].Value = {s2.Items[0].Value}");
    }
}

s1.Items[0].Value = 1
s2.Items[0].Value = 100

この例では、DeepCopyメソッドでリストの各要素を個別にコピーしているため、s2の変更がs1に影響しません。

多次元配列の取り扱い

多次元配列(例えばint[,])の場合、Cloneメソッドは浅いコピーとなり、配列の要素自体はコピーされません。

多次元配列の深いコピーを行うには、要素を一つずつコピーする必要があります。

以下は2次元配列の深いコピー例です。

public struct StructWithMultiArray
{
    public int[,] Matrix;
    public StructWithMultiArray(int[,] matrix)
    {
        Matrix = matrix;
    }
    public StructWithMultiArray DeepCopy()
    {
        int rows = Matrix.GetLength(0);
        int cols = Matrix.GetLength(1);
        int[,] newMatrix = new int[rows, cols];
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                newMatrix[i, j] = Matrix[i, j];
            }
        }
        return new StructWithMultiArray(newMatrix);
    }
}
class Program
{
    static void Main()
    {
        int[,] matrix = { { 1, 2 }, { 3, 4 } };
        StructWithMultiArray s1 = new StructWithMultiArray(matrix);
        StructWithMultiArray s2 = s1.DeepCopy();
        s2.Matrix[0, 0] = 100;
        Console.WriteLine($"s1.Matrix[0,0] = {s1.Matrix[0, 0]}");
        Console.WriteLine($"s2.Matrix[0,0] = {s2.Matrix[0, 0]}");
    }
}

s1.Matrix[0,0] = 1
s2.Matrix[0,0] = 100

このように、多次元配列の深いコピーは手動で要素をコピーする必要があります。

メモリ消費とスピードのトレードオフ

深いコピーは元のデータと完全に独立した複製を作るため、メモリ消費が増加し、コピー処理に時間がかかることがあります。

特に大きな配列や複雑なオブジェクトグラフを持つ構造体では、パフォーマンスに影響を与える可能性があります。

項目	浅いコピー	深いコピー
メモリ消費	低い(参照共有)	高い(新しいオブジェクトを生成)
コピー速度	高速(ビット単位コピー)	低速(再帰的コピーや新規生成)
データの独立性	共有参照による副作用の可能性あり	完全に独立
実装の複雑さ	簡単(自動生成)	複雑(手動実装が必要)

深いコピーを多用するとメモリ使用量が増え、GC負荷も高まるため、必要な場合に限定して使うことが望ましいです。

パフォーマンスが重要な場面では、inパラメータやreadonly structの活用、イミュータブル設計などの代替手段も検討してください。

readonly構造体による防御策

readonly struct の宣言効果

C# 7.2以降で導入されたreadonly structは、構造体の不変性を保証しつつ、コピーの発生を抑制するための重要な機能です。

readonly structとして宣言された構造体は、そのインスタンスの状態を変更できないことをコンパイラが保証します。

readonly structを使うと、以下の効果があります。

インスタンスのフィールドがすべて読み取り専用であることを強制
メソッド内での防御的コピー(defensive copy)を減らせる
不変性を保証し、スレッドセーフな設計に寄与する

例えば、以下のようにreadonly structを宣言します。

public readonly struct Point
{
    public double X { get; }
    public double Y { get; }
    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }
    public double DistanceFromOrigin()
    {
        return Math.Sqrt(X * X + Y * Y);
    }
}
class Program
{
    static void Main()
    {
        Point p = new Point(3, 4);
        Console.WriteLine($"Distance: {p.DistanceFromOrigin()}");
    }
}

Distance: 5

この例では、Point構造体がreadonlyとして宣言されているため、XやYの値は変更できません。

これにより、構造体の状態が不変であることが保証されます。

フィールド・プロパティの制約

readonly structでは、すべてのインスタンスフィールドが読み取り専用でなければなりません。

つまり、readonly修飾子が自動的に付与され、フィールドの変更はコンパイルエラーとなります。

また、プロパティに関しても、セッターを持つプロパティは許可されません。

読み取り専用のプロパティ(getのみ)でなければなりません。

以下のコードはコンパイルエラーとなる例です。

public readonly struct InvalidStruct
{
    public int X; // エラー：readonly structのフィールドはreadonlyでなければならない
    public int Y { get; set; } // エラー：readonly structのプロパティにsetは不可
}

この制約により、readonly structは不変なデータ構造として設計されることが強制されます。

これにより、構造体のインスタンスが意図せず変更されるリスクを減らせます。

JIT最適化とコピー削減

readonly structはJITコンパイラによる最適化の恩恵も受けやすくなります。

特に、構造体のメソッド呼び出し時に発生する防御的コピー(defensive copy)を削減できるため、パフォーマンス向上につながります。

通常、構造体のインスタンスメソッドを呼び出す際、thisパラメータは値渡しされるため、メソッド内でコピーが発生することがあります。

これが防御的コピーです。

readonly structの場合、thisは読み取り専用の参照として渡されるため、コピーが不要になります。

以下の例で比較します。

using System;

public struct MutableStruct
{
    public int Value;
    public int GetValue()
    {
        return Value;
    }
}

public readonly struct ReadonlyStruct
{
    public readonly int Value;

    // コンストラクタでreadonlyフィールドを初期化
    public ReadonlyStruct(int value)
    {
        Value = value;
    }

    public int GetValue()
    {
        return Value;
    }
}

class Program
{
    static void Main()
    {
        MutableStruct m = new MutableStruct { Value = 10 };
        ReadonlyStruct r = new ReadonlyStruct(20);

        Console.WriteLine(m.GetValue());
        Console.WriteLine(r.GetValue());
    }
}

10
20

このコード自体は同じ動作をしますが、JITの最適化ではReadonlyStructのGetValue呼び出し時に防御的コピーが発生しません。

一方、MutableStructでは防御的コピーが発生する可能性があります。

防御的コピーは特に大きな構造体でパフォーマンスに影響を与えるため、readonly structを使うことでコピー回数を減らし、効率的なコードを実現できます。

このように、readonly structは構造体の不変性を保証しつつ、コピーの発生を抑制する効果があります。

フィールドやプロパティの制約により安全な設計を促し、JIT最適化によってパフォーマンス向上にも寄与します。

構造体の設計時には積極的に活用したい機能です。

言語機能を活かした最適化

Span<T> と stackalloc

Span<T>はC# 7.2以降で導入された構造体で、メモリの連続領域を安全かつ効率的に扱うための型です。

Span<T>はスタック上のメモリやヒープ上の配列など、さまざまなメモリ領域を参照でき、コピーを伴わずにデータ操作が可能です。

特にstackallocと組み合わせることで、スタック上に一時的な配列を確保し、高速な処理が実現できます。

stackallocは固定サイズのメモリをスタックに割り当てる機能で、GCの影響を受けずに高速に動作します。

以下はSpan<T>とstackallocを使った例です。

using System;
class Program
{
    static void Main()
    {
        // stackallocでスタック上に10個のint領域を確保
        Span<int> numbers = stackalloc int[10];
        for (int i = 0; i < numbers.Length; i++)
        {
            numbers[i] = i * i;
        }
        for (int i = 0; i < numbers.Length; i++)
        {
            Console.WriteLine($"numbers[{i}] = {numbers[i]}");
        }
    }
}

numbers[0] = 0
numbers[1] = 1
numbers[2] = 4
numbers[3] = 9
numbers[4] = 16
numbers[5] = 25
numbers[6] = 36
numbers[7] = 49
numbers[8] = 64
numbers[9] = 81

この例では、stackallocで確保したメモリをSpan<int>でラップし、配列のように扱っています。

スタック上のメモリなのでGCの負荷がなく、高速にアクセスできます。

Span<T>は構造体であり、コピーしても参照先のメモリは共有されるため、コピーコストが非常に低いのも特徴です。

これにより、大きなデータのコピーを避けつつ安全に操作できます。

Unsafe.As の活用注意点

Unsafe.As<TFrom, TTo>はSystem.Runtime.CompilerServices.Unsafeクラスのメソッドで、型の変換を高速に行うための低レベルAPIです。

メモリ上のデータを別の型として扱うことができ、ボクシングやコピーを回避する際に使われます。

例えば、構造体のバイト列を別の構造体に変換したり、参照型と値型の間でポインタ操作を行う場合に利用されます。

以下はUnsafe.Asの簡単な例です。

using System;
using System.Runtime.CompilerServices;
public struct Point
{
    public int X;
    public int Y;
}
class Program
{
    static void Main()
    {
        Point p = new Point { X = 10, Y = 20 };
        // Pointをint配列として扱う(危険な例)
        ref int firstField = ref Unsafe.As<Point, int>(ref p);
        firstField = 100; // p.Xを書き換える
        Console.WriteLine($"p.X = {p.X}, p.Y = {p.Y}");
    }
}

p.X = 100, p.Y = 20

このように、Unsafe.Asは型安全性を無視してメモリを直接操作できるため、パフォーマンス向上に役立つ反面、誤用するとメモリ破壊や予期しない動作を引き起こします。

活用時の注意点は以下の通りです。

型のサイズやレイアウトが一致していることを保証する必要がある
不正な型変換は未定義動作を招く
マルチスレッド環境での安全性に注意する
基本的には安全なコードで代替できない場合に限定して使う

Unsafe.Asはパフォーマンスクリティカルな場面でのみ使い、通常は安全なC#コードを優先してください。

ボクシング回避テクニック

構造体は値型であるため、インターフェースやobject型に代入するとボクシングが発生します。

ボクシングは値型をヒープ上のオブジェクトに変換する処理で、パフォーマンス低下やGC負荷増加の原因となります。

ボクシングを回避するためのテクニックをいくつか紹介します。

ジェネリクスの活用

ジェネリックメソッドやクラスを使うと、型パラメータが値型の場合でもボクシングを回避できます。

public interface IDisplay
{
    void Display();
}
public struct Point : IDisplay
{
    public int X, Y;
    public void Display() => Console.WriteLine($"X={X}, Y={Y}");
}
class Program
{
    static void Show<T>(T item) where T : IDisplay
    {
        item.Display(); // ボクシングなしで呼び出せる
    }
    static void Main()
    {
        Point p = new Point { X = 1, Y = 2 };
        Show(p);
    }
}

X=1, Y=2

この例では、Show<T>がジェネリックであるため、Pointのボクシングが発生しません。

inパラメータの利用

in修飾子を使うことで、構造体を読み取り専用の参照として渡し、ボクシングを減らせます。

public struct Point
{
    public int X, Y;
    public void Display() => Console.WriteLine($"X={X}, Y={Y}");
}
class Program
{
    static void Show(in Point p)
    {
        p.Display();
    }
    static void Main()
    {
        Point p = new Point { X = 3, Y = 4 };
        Show(p);
    }
}

X=3, Y=4

明示的なキャスト回避

object型や非ジェネリックインターフェースに代入するとボクシングが発生するため、可能な限りジェネリックや具体型を使い、明示的なキャストを避けることが重要です。

これらの言語機能を活用することで、構造体のコピーやボクシングによるパフォーマンス低下を抑え、安全かつ高速なコードを実現できます。

特に大規模なデータ処理やリアルタイム処理では効果的です。

実装サンプルカタログ

シンプルな数値座標構造体

数値座標を表すシンプルな構造体は、構造体の基本的な使い方を理解するのに最適です。

以下は2次元座標を表すPoint構造体の例です。

public struct Point
{
    public double X;
    public double Y;
    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }
    public void Move(double dx, double dy)
    {
        X += dx;
        Y += dy;
    }
    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}
class Program
{
    static void Main()
    {
        Point p1 = new Point(1.0, 2.0);
        Point p2 = p1; // 値のコピー
        p2.Move(3.0, 4.0);
        Console.WriteLine($"p1: {p1}");
        Console.WriteLine($"p2: {p2}");
    }
}

p1: (1, 2)
p2: (4, 6)

この例では、p1の値がp2にコピーされているため、p2を移動してもp1には影響しません。

シンプルな数値型フィールドのみで構成されているため、浅いコピーでも問題なく動作します。

参照型フィールドを持つ複合構造体

構造体のフィールドに参照型を含む場合、コピーは浅いコピーとなり、参照先の共有が発生します。

以下は参照型フィールドを持つ複合構造体の例です。

public struct Person
{
    public string Name;
    public int[] Scores;
    public Person(string name, int[] scores)
    {
        Name = name;
        Scores = scores;
    }
    public void UpdateScore(int index, int newScore)
    {
        if (Scores != null && index >= 0 && index < Scores.Length)
        {
            Scores[index] = newScore;
        }
    }
    public override string ToString()
    {
        string scoresStr = Scores != null ? string.Join(", ", Scores) : "null";
        return $"Name: {Name}, Scores: [{scoresStr}]";
    }
}
class Program
{
    static void Main()
    {
        int[] scores = { 80, 90, 85 };
        Person p1 = new Person("Alice", scores);
        Person p2 = p1; // 浅いコピー(Scores配列の参照がコピーされる)
        p2.UpdateScore(0, 100);
        Console.WriteLine($"p1: {p1}");
        Console.WriteLine($"p2: {p2}");
    }
}

p1: Name: Alice, Scores: [100, 90, 85]
p2: Name: Alice, Scores: [100, 90, 85]

この例では、Scores配列が共有されているため、p2のスコア変更がp1にも反映されています。

参照型フィールドを持つ構造体のコピーは浅いコピーであることに注意が必要です。

ネストされた構造体のコピー

構造体のフィールドに別の構造体を持つ場合、コピーはネストされた構造体も含めてビット単位でコピーされます。

以下はネストされた構造体の例です。

public struct Address
{
    public string City;
    public string Street;
    public Address(string city, string street)
    {
        City = city;
        Street = street;
    }
    public override string ToString()
    {
        return $"{City}, {Street}";
    }
}
public struct Employee
{
    public string Name;
    public Address Address;
    public Employee(string name, Address address)
    {
        Name = name;
        Address = address;
    }
    public override string ToString()
    {
        return $"Name: {Name}, Address: {Address}";
    }
}
class Program
{
    static void Main()
    {
        Address addr1 = new Address("Tokyo", "Chiyoda");
        Employee e1 = new Employee("Bob", addr1);
        Employee e2 = e1; // ネストされたAddressもコピーされる
        e2.Address.City = "Osaka";
        Console.WriteLine($"e1: {e1}");
        Console.WriteLine($"e2: {e2}");
    }
}

e1: Name: Bob, Address: Tokyo, Chiyoda
e2: Name: Bob, Address: Osaka, Chiyoda

この例では、Employeeのコピー時にAddressもコピーされているため、e2.Address.Cityの変更はe1に影響しません。

ただし、Addressのフィールドが参照型であれば、共有が発生する点に注意してください。

Unityでのstruct利用例

Unityではパフォーマンス向上のためにstructが多用されます。

特にVector3やQuaternionなどの数学的なデータは構造体として実装されており、コピーコストを抑えつつ高速に処理されます。

以下はUnityのVector3に似た簡易構造体の例です。

public struct Vector3
{
    public float x;
    public float y;
    public float z;
    public Vector3(float x, float y, float z)
    {
        this.x = x;
        this.y = y;
        this.z = z;
    }
    public float Magnitude()
    {
        return (float)Math.Sqrt(x * x + y * y + z * z);
    }
    public void Normalize()
    {
        float mag = Magnitude();
        if (mag > 0)
        {
            x /= mag;
            y /= mag;
            z /= mag;
        }
    }
    public override string ToString()
    {
        return $"({x}, {y}, {z})";
    }
}
class Program
{
    static void Main()
    {
        Vector3 v1 = new Vector3(3f, 4f, 0f);
        Vector3 v2 = v1; // 値のコピー
        v2.Normalize();
        Console.WriteLine($"v1: {v1}");
        Console.WriteLine($"v2: {v2}");
    }
}

v1: (3, 4, 0)
v2: (0.6, 0.8, 0)

UnityのVector3のように、値型である構造体を使うことで、コピーは高速かつ安全に行われます。

ゲーム開発ではこうした構造体を活用し、GC負荷を抑えつつリアルタイム処理を実現しています。

パフォーマンス計測と最適化

BenchmarkDotNetでのベンチマーク手順

C#で構造体のコピーや処理のパフォーマンスを正確に計測するには、BenchmarkDotNetという強力なベンチマークライブラリを使うのが一般的です。

BenchmarkDotNetは高精度な計測と詳細なレポート生成を行い、JIT最適化やGCの影響も考慮した信頼性の高い結果を提供します。

以下にBenchmarkDotNetを使った基本的なベンチマーク手順を示します。

プロジェクトにBenchmarkDotNetを導入する

NuGetパッケージマネージャーからBenchmarkDotNetをインストールします。

Install-Package BenchmarkDotNet

ベンチマーク対象のメソッドを定義する

[Benchmark]属性を付けたメソッドを用意します。

例えば、構造体のコピーを計測する場合は以下のようにします。

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public struct Point
{
    public int X, Y;
    public Point(int x, int y) { X = x; Y = y; }
}
public class StructCopyBenchmark
{
    private Point p1 = new Point(10, 20);
    [Benchmark]
    public Point CopyByAssignment()
    {
        Point p2 = p1; // 浅いコピー
        return p2;
    }
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<StructCopyBenchmark>();
    }
}

ベンチマークを実行する

BenchmarkRunner.Run<T>()を呼び出すと、ベンチマークが実行され、結果がコンソールに表示されます。

結果の確認

実行結果には、平均実行時間、メモリ割り当て量、呼び出し回数などが詳細に表示されます。

これにより、コピー方法の違いによるパフォーマンス差を定量的に把握できます。

BenchmarkDotNetは多くのオプションを持ち、JITの影響を排除したり、複数環境での比較も可能です。

構造体のコピーや深いコピーの最適化を検証する際に非常に役立ちます。

IL逆アセンブルでの確認ポイント

C#のコードがコンパイルされると、中間言語(IL)に変換されます。

ILを逆アセンブルして確認することで、構造体のコピーがどのように実装されているか、余計なコピーやボクシングが発生していないかを詳細に把握できます。

IL逆アセンブルには、Visual Studioの「IL Disassembler(ildasm)」や、dotnet CLIのdotnet ildasm、またはILSpyやdnSpyなどのツールが使えます。

確認すべきポイント

ldobj / stobj 命令の使用

構造体のコピーはldobj(ロード)とstobj(ストア)命令で行われることが多いです。

これらが頻繁に使われている場合、コピーが発生していることを示します。

ボクシングの有無

box命令がある場合、値型が参照型に変換されているためボクシングが発生しています。

パフォーマンス低下の原因となるため注意が必要です。

防御的コピー(defensive copy)

構造体のthisパラメータがメソッド呼び出し時にコピーされているかどうかを確認します。

ldarga(アドレスをロード)命令が使われていればコピーを避けている可能性があります。

call と callvirt の違い

構造体のメソッド呼び出しは通常call命令ですが、インターフェース経由だとcallvirtとなり、ボクシングが発生しやすいです。

例：浅いコピーのIL断片

IL_0000: ldloca.s p1
IL_0002: ldobj Point
IL_0007: stloc.1

この例はp1の値をコピーしていることを示します。

ILを読むことで、ソースコードの最適化状況やコピーの発生箇所を正確に把握でき、パフォーマンス改善のヒントを得られます。

キャッシュミスとアラインメント

CPUのパフォーマンスに大きく影響する要素として、キャッシュミスとメモリアラインメントがあります。

構造体のコピーやアクセスパターンを最適化する際にこれらを意識することが重要です。

キャッシュミス

CPUは高速なキャッシュメモリを持ち、頻繁にアクセスするデータをキャッシュに保持します。

構造体のコピーやアクセスがキャッシュラインの境界をまたぐと、キャッシュミスが発生し、メインメモリからの遅い読み込みが発生します。

大きな構造体を頻繁にコピーすると、キャッシュミスが増え、パフォーマンスが低下します。

小さな構造体に分割したり、連続したメモリ配置を意識することでキャッシュ効率を改善できます。

メモリアラインメント

CPUは特定のバイト境界にデータが揃っている(アラインメントされている)ことを好みます。

アラインメントが悪いと、複数回のメモリアクセスが必要になり、処理が遅くなります。

C#の構造体はデフォルトで適切にアラインメントされますが、StructLayout属性で明示的に制御することも可能です。

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct PackedStruct
{
    public byte A;
    public int B;
}

この例はパックサイズを1バイトに設定し、アラインメントを変更していますが、パフォーマンスに悪影響を与えることがあるため注意が必要です。

最適化のポイント

構造体はできるだけ小さくし、頻繁なコピーを避ける
連続したメモリ領域に配置し、キャッシュ効率を高める
アラインメントを意識し、CPUのアクセス効率を最大化する
大きなデータは参照型やSpan<T>で扱い、コピーコストを抑える

これらを踏まえた設計と実装が、構造体のパフォーマンス最適化において重要です。

テスト観点

同値性と同一性の検証

構造体のテストにおいて重要なポイントの一つが「同値性」と「同一性」の検証です。

構造体は値型であるため、同じ値を持つ別のインスタンスと等しいかどうかを正しく判定できることが求められます。

同値性(Equality)

2つの構造体が持つデータの内容が等しいかどうかを判定します。

値が同じであれば同値とみなします。

同一性(Identity)

2つの変数が同じインスタンスを参照しているかどうかを判定します。

構造体は値型なので、同一性の概念はクラスほど重要ではありませんが、参照型フィールドを持つ場合は注意が必要です。

Equals／GetHashCode 実装指針

構造体でEqualsとGetHashCodeを適切に実装することは、同値性の検証に不可欠です。

デフォルトのValueType.Equalsはリフレクションを使うためパフォーマンスが低く、また参照型フィールドの比較が浅い場合があります。

以下のポイントを押さえて実装しましょう。

Equalsのオーバーライド

全てのフィールドを比較し、値が等しい場合にtrueを返すようにします。

参照型フィールドはEqualsメソッドを使って比較します。

GetHashCodeのオーバーライド

フィールドのハッシュコードを組み合わせて一意性を高めます。

HashCode.Combine(C# 8.0以降)を使うと簡潔に書けます。

IEquatable<T>の実装

型安全かつパフォーマンスの良いEqualsを提供するためにIEquatable<T>を実装することが推奨されます。

以下は実装例です。

public struct SampleStruct : IEquatable<SampleStruct>
{
    public int Id;
    public string Name;
    public bool Equals(SampleStruct other)
    {
        return Id == other.Id && string.Equals(Name, other.Name);
    }
    public override bool Equals(object obj)
    {
        return obj is SampleStruct other && Equals(other);
    }
    public override int GetHashCode()
    {
        return HashCode.Combine(Id, Name);
    }
}

この実装により、SampleStructの同値性を正しく判定でき、ハッシュベースのコレクションDictionaryやHashSetでも正しく動作します。

参照分離を保証するユニットテスト

構造体が参照型フィールドを持つ場合、コピーが浅いコピーとなり参照先が共有されることがあります。

これを防ぐために、深いコピーや独立性を保証するユニットテストを作成することが重要です。

テストのポイントは以下の通りです。

コピー後の参照型フィールドが異なるインスタンスであることを確認する

コピー元とコピー先の参照型フィールドが同じオブジェクトを指していないか検証します。

コピー先の変更がコピー元に影響しないことを検証する

コピー先の参照型フィールドの内容を変更し、コピー元の内容が変わらないことを確認します。

以下は簡単なユニットテスト例(xUnitを想定)です。

public struct SampleStruct
{
    public int[] Numbers;
    public SampleStruct DeepCopy()
    {
        return new SampleStruct
        {
            Numbers = (int[])Numbers.Clone()
        };
    }
}
public class SampleStructTests
{
    [Fact]
    public void DeepCopy_ShouldCreateIndependentArray()
    {
        var original = new SampleStruct { Numbers = new int[] { 1, 2, 3 } };
        var copy = original.DeepCopy();
        // 参照が異なることを確認
        Assert.NotSame(original.Numbers, copy.Numbers);
        // コピー先を変更しても元に影響しないことを確認
        copy.Numbers[0] = 100;
        Assert.Equal(1, original.Numbers[0]);
        Assert.Equal(100, copy.Numbers[0]);
    }
}

このテストにより、コピーが浅いコピーではなく、参照分離が保証されていることを検証できます。

これらのテスト観点を踏まえ、構造体の同値性や参照分離を正しく検証することで、安全で予測可能な動作を保証できます。

特に参照型フィールドを持つ構造体では、深いコピーの実装とその検証が欠かせません。

シリアライズを利用したコピー応用

JSONシリアライズによる一時的ディープコピー

構造体や複雑なオブジェクトのディープコピーを手軽に実現する方法の一つに、JSONシリアライズを利用する手法があります。

これは、オブジェクトをJSON形式の文字列にシリアライズし、その文字列を再度デシリアライズして新しいインスタンスを生成することで、完全なコピーを作成する方法です。

この方法のメリットは、コピー処理を自前で実装する必要がなく、ネストされた参照型フィールドも含めて再帰的にコピーできる点にあります。

ただし、パフォーマンスは専用のコピー実装に比べて劣るため、一時的なコピーやテスト用途に向いています。

以下はSystem.Text.Jsonを使ったJSONシリアライズによるディープコピーの例です。

using System;
using System.Text.Json;
public struct SampleStruct
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int[] Scores { get; set; }
}
class Program
{
    static T DeepCopyByJson<T>(T obj)
    {
        var json = JsonSerializer.Serialize(obj);
        return JsonSerializer.Deserialize<T>(json);
    }
    static void Main()
    {
        var original = new SampleStruct
        {
            Id = 1,
            Name = "Alice",
            Scores = new int[] { 90, 80, 70 }
        };
        var copy = DeepCopyByJson(original);
        copy.Scores[0] = 100;
        Console.WriteLine($"original.Scores[0] = {original.Scores[0]}");
        Console.WriteLine($"copy.Scores[0] = {copy.Scores[0]}");
    }
}

original.Scores[0] = 90
copy.Scores[0] = 100

この例では、DeepCopyByJsonメソッドでJSONにシリアライズ・デシリアライズを行い、originalとcopyが独立したインスタンスとなっています。

copyの変更はoriginalに影響しません。

ただし、以下の点に注意が必要です。

シリアライズ対象の型はパブリックなプロパティやフィールドを持つ必要がある
循環参照がある場合は例外が発生することがある
パフォーマンスは専用のコピー実装に比べて低い
シリアライズ設定によっては一部の型が正しく処理されない場合がある

これらを踏まえ、用途に応じて使い分けることが重要です。

BinaryFormatter廃止と代替手段

かつて.NETでディープコピーや永続化に広く使われていたBinaryFormatterは、セキュリティ上の問題から.NET 5以降で廃止されました。

BinaryFormatterはバイナリ形式でオブジェクトをシリアライズし、高速かつコンパクトなデータを生成できましたが、悪意あるデータによる攻撃リスクが指摘されています。

そのため、BinaryFormatterの代替として以下の手段が推奨されています。

System.Text.Json

JSON形式でのシリアライズを提供し、安全かつ高速です。

構造体のディープコピーにも利用可能です。

DataContractSerializer

XML形式のシリアライズを行い、柔軟な設定が可能です。

主にWCFなどで使われます。

protobuf-netなどのサードパーティ製ライブラリ

Protocol Buffers形式で高速かつコンパクトなシリアライズを実現します。

パフォーマンス重視の用途に適しています。

MessagePack

バイナリ形式の高速シリアライズライブラリで、JSONよりも高速かつ小さいサイズでデータを扱えます。

以下はMessagePackを使った例です。

using System;
using MessagePack;
[MessagePackObject]
public struct SampleStruct
{
    [Key(0)]
    public int Id { get; set; }
    [Key(1)]
    public string Name { get; set; }
    [Key(2)]
    public int[] Scores { get; set; }
}
class Program
{
    static T DeepCopyByMessagePack<T>(T obj)
    {
        var bytes = MessagePackSerializer.Serialize(obj);
        return MessagePackSerializer.Deserialize<T>(bytes);
    }
    static void Main()
    {
        var original = new SampleStruct
        {
            Id = 1,
            Name = "Bob",
            Scores = new int[] { 85, 75, 65 }
        };
        var copy = DeepCopyByMessagePack(original);
        copy.Scores[1] = 99;
        Console.WriteLine($"original.Scores[1] = {original.Scores[1]}");
        Console.WriteLine($"copy.Scores[1] = {copy.Scores[1]}");
    }
}

original.Scores[1] = 75
copy.Scores[1] = 99

このように、BinaryFormatterの廃止に伴い、安全かつ高速な代替手段を選択することが重要です。

用途や環境に応じて適切なシリアライズ方法を選び、ディープコピーやデータ永続化に活用してください。

自動生成による効率化

Source GeneratorでのCloneコード生成

C# 9.0以降で利用可能なSource Generatorは、コンパイル時にコードを自動生成する機能です。

これを活用すると、構造体のディープコピー用のCloneメソッドを自動生成でき、手動での実装ミスや冗長なコードを減らせます。

Source Generatorは、ソースコードを解析して必要なコードを生成し、コンパイルに組み込むため、実行時のオーバーヘッドがありません。

特に複雑な構造体や多数の構造体で同様のコピー処理が必要な場合に効果的です。

実装イメージ

属性でマークアップ

コピー生成を行いたい構造体にカスタム属性を付与します。

Source Generatorが属性を検出

コンパイル時に対象の構造体を検出し、Cloneメソッドを生成します。

生成されたコードがコンパイルに組み込まれる

生成コードは通常のコードと同様に扱われ、IDEの補完やリファクタリングもサポートされます。

以下は簡単な例です。

// コピー生成対象を示すカスタム属性
[AttributeUsage(AttributeTargets.Struct)]
public class GenerateCloneAttribute : Attribute { }
// コピー対象の構造体
[GenerateClone]
public struct SampleStruct
{
    public int Id;
    public string Name;
    public int[] Scores;
}

Source GeneratorはこのSampleStructに対して以下のようなCloneメソッドを自動生成します。

public SampleStruct Clone()
{
    return new SampleStruct
    {
        Id = this.Id,
        Name = this.Name,
        Scores = (int[])this.Scores.Clone()
    };
}

メリット

手動実装の手間とミスを削減
一貫性のあるコピー処理を保証
大規模プロジェクトでの保守性向上
実行時のパフォーマンスに影響なし

注意点

参照型フィールドの深いコピーロジックはカスタマイズが必要な場合がある
Source Generatorの開発にはRoslyn APIの知識が必要
プロジェクトのビルド時間に影響を与える可能性がある

IL Weavingツールの導入可否

IL Weavingは、ビルド後の中間言語(IL)コードに対して後処理を行い、コードの自動挿入や改変を行う技術です。

FodyやPostSharpなどのツールが代表的で、Cloneメソッドの自動生成やトレーシング、ロギングなどに利用されます。

利用メリット

ソースコードを変更せずに機能追加が可能
既存のバイナリに対しても適用できる
複雑なコード生成や横断的関心事の実装に強力

導入時の検討ポイント

ビルドプロセスの複雑化

IL Weavingはビルド後にILを操作するため、ビルドパイプラインが複雑になり、トラブルシューティングが難しくなることがあります。

デバッグの難易度上昇

自動挿入されたコードはソースに直接現れないため、デバッグ時に挙動が分かりづらくなることがあります。

パフォーマンス影響

過剰なIL操作は実行時のパフォーマンスに影響を与える可能性がありますが、適切に設計すれば問題ありません。

メンテナンス性

ツールのバージョンアップや環境変化に伴うメンテナンスコストが発生します。

適用例

構造体のCloneメソッドを自動生成する場合、IL Weavingで以下のような処理を行えます。

コピーコンストラクタやCloneメソッドの自動挿入
参照型フィールドの深いコピー処理の自動追加
既存コードへの影響を最小限に抑えつつ機能拡張

IL Weavingは強力な技術ですが、プロジェクトの規模やチームのスキルセット、メンテナンス体制を考慮して導入を検討すべきです。

小規模や中規模のプロジェクトではSource Generatorの方が扱いやすく、ビルド時の透明性も高いため推奨されます。

一方、大規模で複雑な横断的処理が必要な場合はIL Weavingが有効な選択肢となります。

よくある落とし穴

暗黙のボクシングでの性能低下

構造体は値型であるため、通常はスタック上に直接データが格納されますが、インターフェース型やobject型に代入されると「ボクシング」が発生します。

ボクシングとは、値型をヒープ上のオブジェクトに変換する処理で、これによりパフォーマンスが大幅に低下することがあります。

暗黙のボクシングは、意図せず発生しやすいので注意が必要です。

例えば、以下のようなケースです。

public interface IDisplay
{
    void Display();
}
public struct Point : IDisplay
{
    public int X, Y;
    public void Display() => Console.WriteLine($"X={X}, Y={Y}");
}
class Program
{
    static void Show(IDisplay display)
    {
        display.Display();
    }
    static void Main()
    {
        Point p = new Point { X = 1, Y = 2 };
        Show(p); // ここでボクシングが発生
    }
}

X=1, Y=2

この例では、Showメソッドの引数がインターフェース型IDisplayであるため、Point構造体がボクシングされてヒープにコピーされます。

これにより、GC負荷が増え、パフォーマンスが低下します。

対策としては以下が挙げられます。

ジェネリックメソッドを使い、型パラメータにインターフェース制約を付けることでボクシングを回避する
inパラメータを使い、読み取り専用の参照渡しにする
可能な限り構造体をインターフェース型で扱わない

マルチスレッド環境でのデータ競合

構造体は値型であるため、コピーが頻繁に発生しますが、参照型フィールドを持つ場合は注意が必要です。

特にマルチスレッド環境で複数のスレッドが同じ参照型フィールドを共有すると、データ競合や不整合が発生しやすくなります。

例えば、参照型の配列やリストを構造体のフィールドとして持ち、複数スレッドで同時に書き込みを行うと、予期しない動作や例外が発生します。

public struct SharedData
{
    public int[] Values;
}
class Program
{
    static SharedData data = new SharedData { Values = new int[10] };
    static void ThreadProc()
    {
        for (int i = 0; i < 10; i++)
        {
            data.Values[i]++; // 競合の可能性あり
        }
    }
    static void Main()
    {
        var t1 = new System.Threading.Thread(ThreadProc);
        var t2 = new System.Threading.Thread(ThreadProc);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine(string.Join(", ", data.Values));
    }
}

2, 2, 2, 2, 2, 2, 2, 2, 2, 2

このようなコードはスレッドセーフではなく、Values配列の要素が競合して不正な値になる可能性があります。

対策としては以下が有効です。

参照型フィールドの共有を避け、スレッドごとに独立したコピーを持つ
ロックやスレッドセーフなコレクションを利用する
イミュータブルな設計を採用し、状態変更を避ける

プロパティ経由の不意なコピー

構造体のプロパティを経由してアクセスすると、不意にコピーが発生することがあります。

これは、プロパティのゲッターが構造体の値を返すため、呼び出し元にコピーが渡されるためです。

例えば、以下のようなケースです。

public struct Container
{
    public Point PointValue { get; set; }
}
public struct Point
{
    public int X, Y;
    public void Move(int dx, int dy)
    {
        X += dx;
        Y += dy;
    }
}
class Program
{
    static void Main()
    {
        Container c = new Container { PointValue = new Point { X = 1, Y = 2 } };
        c.PointValue.Move(10, 20); // ここでコピーが発生し、変更が反映されない
        Console.WriteLine($"X={c.PointValue.X}, Y={c.PointValue.Y}");
    }
}

X=1, Y=2

この例では、c.PointValueのゲッターがPointのコピーを返すため、Moveメソッドはコピーに対して実行され、c.PointValue自体は変更されません。

この問題を回避するには以下の方法があります。

プロパティの値を一時変数に代入し、その変数を操作してから再度プロパティに代入する

var p = c.PointValue;
p.Move(10, 20);
c.PointValue = p;

プロパティをref戻り値にして、参照を直接操作できるようにする(C# 7.0以降)

public struct Container
{
    private Point pointValue;
    public ref Point PointValue => ref pointValue;
}

構造体の設計を見直し、ミューテーションを避けるイミュータブル設計にする

これらの落とし穴は、構造体の特性を理解せずに使うとパフォーマンス低下やバグの原因となります。

設計段階で注意深く検討し、適切な対策を講じることが重要です。

他言語との比較で理解を深める

C++のstructとのコピー挙動差

C++におけるstructは、C#の構造体と似ていますが、コピーの挙動やメモリ管理にいくつか重要な違いがあります。

C++のstructは基本的にクラスと同じくユーザー定義型であり、デフォルトで値のコピーが行われますが、コピーコンストラクタやムーブコンストラクタを自分で定義できる点が特徴です。

コピーの基本動作

C++のstructは値型として振る舞い、代入や関数呼び出し時にコピーが発生します。

ただし、C++ではコピーコンストラクタを自分で実装することで、コピーの挙動を細かく制御できます。

これにより、浅いコピーや深いコピーを明示的に切り替えられます。

struct Point {
    int x, y;
    // コピーコンストラクタ(デフォルトで自動生成される)
    Point(const Point& other) : x(other.x), y(other.y) {}
};

ムーブセマンティクス

C++11以降はムーブコンストラクタやムーブ代入演算子を実装でき、リソースの所有権を効率的に移動させることが可能です。

これにより、大きなデータのコピーコストを削減できます。

struct Buffer {
    int* data;
    size_t size;
    // ムーブコンストラクタ
    Buffer(Buffer&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
};

C#との違い

コピー制御の柔軟性

C++はコピーコンストラクタやムーブコンストラクタを自由に定義できるため、コピーの挙動を細かく制御可能です。

C#の構造体はコピーコンストラクタを自動生成しないため、明示的に実装しない限り浅いコピーになります。

メモリ管理

C++は手動でメモリ管理を行うことが多く、コピー時にリソースの所有権をどう扱うかが重要です。

C#はガベージコレクションがあるため、メモリ管理の負担は軽減されています。

ムーブセマンティクスの有無

C#にはムーブコンストラクタの概念がなく、値のムーブは自動的に行われません。

これにより、大きな構造体のコピーコストが高くなることがあります。

参照型との混在

C#の構造体は参照型フィールドを持つことが多く、浅いコピー時に参照共有が発生します。

C++ではポインタやスマートポインタを使い、コピー時の挙動を明示的に制御します。

このように、C++のstructはコピーの挙動を柔軟に制御できる一方、C#はシンプルで安全な値型コピーを標準としています。

用途や設計方針に応じて使い分けが必要です。

RustのCopyトレイトとの対比

RustのCopyトレイトは、値のビット単位コピーを意味し、C#の構造体の浅いコピーに近い概念です。

Rustでは、Copyトレイトを実装した型は代入や関数呼び出し時に自動的にコピーされ、所有権の移動が発生しません。

RustのCopyトレイトの特徴

明示的なトレイト実装

Rustでは、型がCopyトレイトを実装しているかどうかでコピーの挙動が決まります。

プリミティブ型や小さな構造体は自動的にCopyを実装しますが、大きな構造体や参照型を含む型はCopyを実装できません。

所有権と借用のモデル

Rustは所有権システムを持ち、値のムーブや借用を厳密に管理します。

Copy型は所有権のムーブではなくコピーが行われるため、使いやすい反面、コピーコストに注意が必要です。

イミュータブルとミュータブルの区別

Rustでは変数のミュータビリティが明示的で、Copy型の値もミュータブルかイミュータブルかで挙動が変わります。

C#との違い

項目	C#構造体	Rustの`Copy`トレイト
コピーの明示性	すべての構造体は値コピーされる	`Copy`トレイトを実装した型のみ自動コピー
所有権管理	ガベージコレクションに依存	所有権と借用の厳密な管理
参照型フィールドの扱い	参照型フィールドは浅いコピーで共有	`Copy`型は参照型を含めないことが多い
ムーブセマンティクス	なし	ムーブとコピーが明確に区別される
不変性の保証	`readonly struct`で不変性を表現	変数のミュータビリティで制御

例：RustのCopyトレイト

#[derive(Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}
fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1; // コピーが発生
    println!("p1: ({}, {})", p1.x, p1.y);
    println!("p2: ({}, {})", p2.x, p2.y);
}