【C#】構造体のサイズを正確に取得する方法とレイアウト制御のポイント

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct Point
{
    public int X;
    public int Y;
}
class Program
{
    static void Main()
    {
        // 型を指定してサイズを取得
        int sizeByType = Marshal.SizeOf(typeof(Point));
        Console.WriteLine($"型指定でのサイズ: {sizeByType}バイト");
        // インスタンスを渡してサイズを取得
        Point p = new Point { X = 10, Y = 20 };
        int sizeByInstance = Marshal.SizeOf(p);
        Console.WriteLine($"インスタンス指定でのサイズ: {sizeByInstance}バイト");
    }
}

型指定でのサイズ: 8バイト
インスタンス指定でのサイズ: 8バイト

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct BaseStruct
{
    public int A;
}
[StructLayout(LayoutKind.Sequential)]
struct DerivedStruct
{
    public int A;
    public int B;
}
class Program
{
    static void Main()
    {
        BaseStruct baseStruct = new BaseStruct();
        DerivedStruct derivedStruct = new DerivedStruct();
        Console.WriteLine($"BaseStructのサイズ: {Marshal.SizeOf(baseStruct)}バイト");
        Console.WriteLine($"DerivedStructのサイズ: {Marshal.SizeOf(derivedStruct)}バイト");
    }
}

BaseStructのサイズ: 4バイト
DerivedStructのサイズ: 8バイト

using System;
unsafe struct Point
{
    public int X;
    public int Y;
}
class Program
{
    static unsafe void Main()
    {
        int size = sizeof(Point);
        Console.WriteLine($"Point構造体のサイズ: {size}バイト");
    }
}

Point構造体のサイズ: 8バイト

using System;
unsafe struct Buffer
{
    public fixed byte Data[sizeof(int) * 4]; // int 4個分のバッファ
}
class Program
{
    static unsafe void Main()
    {
        Console.WriteLine($"Bufferのサイズ: {sizeof(Buffer)}バイト");
    }
}

Bufferのサイズ: 16バイト

using System;
using System.Runtime.InteropServices;
class Program
{
    static int GetSize<T>() where T : struct
    {
        return Marshal.SizeOf(typeof(T));
    }
    static void Main()
    {
        Console.WriteLine($"intのサイズ: {GetSize<int>()}バイト");
        Console.WriteLine($"Pointのサイズ: {GetSize<Point>()}バイト");
    }
}
[StructLayout(LayoutKind.Sequential)]
struct Point
{
    public int X;
    public int Y;
}

intのサイズ: 4バイト
Pointのサイズ: 8バイト

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct SequentialStruct
{
    public byte A;
    public int B;
    public short C;
}
class Program
{
    static void Main()
    {
        int size = Marshal.SizeOf(typeof(SequentialStruct));
        Console.WriteLine($"SequentialStructのサイズ: {size}バイト");
    }
}

SequentialStructのサイズ: 12バイト

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Explicit)]
struct ExplicitStruct
{
    [FieldOffset(0)]
    public byte A;
    [FieldOffset(4)]
    public int B;
    [FieldOffset(8)]
    public short C;
}
class Program
{
    static void Main()
    {
        int size = Marshal.SizeOf(typeof(ExplicitStruct));
        Console.WriteLine($"ExplicitStructのサイズ: {size}バイト");
    }
}

ExplicitStructのサイズ: 10バイト

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Auto)]
struct AutoStruct
{
    public byte A;
    public int B;
    public short C;
}
class Program
{
    static void Main()
    {
        // Marshal.SizeOfはLayoutKind.Autoでは例外を投げることがある
        try
        {
            int size = Marshal.SizeOf(typeof(AutoStruct));
            Console.WriteLine($"AutoStructのサイズ: {size}バイト");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"例外発生: {ex.Message}");
        }
    }
}

例外発生: Type 'AutoStruct' cannot be marshaled as an unmanaged structure; no meaningful size or offset can be computed.

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct PackedStruct
{
    public byte A;
    public int B;
    public short C;
}
class Program
{
    static void Main()
    {
        int size = Marshal.SizeOf(typeof(PackedStruct));
        Console.WriteLine($"Pack=1のPackedStructのサイズ: {size}バイト");
    }
}

Pack=1のPackedStructのサイズ: 7バイト

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Explicit)]
struct BitFieldStruct
{
    [FieldOffset(0)]
    private byte flags;
    public bool Flag1
    {
        get => (flags & 0x01) != 0;
        set
        {
            if (value) flags |= 0x01;
            else flags &= 0xFE;
        }
    }
    public bool Flag2
    {
        get => (flags & 0x02) != 0;
        set
        {
            if (value) flags |= 0x02;
            else flags &= 0xFD;
        }
    }
    public bool Flag3
    {
        get => (flags & 0x04) != 0;
        set
        {
            if (value) flags |= 0x04;
            else flags &= 0xFB;
        }
    }
}
class Program
{
    static void Main()
    {
        BitFieldStruct bfs = new BitFieldStruct();
        bfs.Flag1 = true;
        bfs.Flag3 = true;
        Console.WriteLine($"Flag1: {bfs.Flag1}");
        Console.WriteLine($"Flag2: {bfs.Flag2}");
        Console.WriteLine($"Flag3: {bfs.Flag3}");
    }
}

Flag1: True
Flag2: False
Flag3: True

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Explicit)]
struct UnionStruct
{
    [FieldOffset(0)]
    public int IntValue;
    [FieldOffset(0)]
    public float FloatValue;
    [FieldOffset(0)]
    public byte Byte0;
    [FieldOffset(1)]
    public byte Byte1;
    [FieldOffset(2)]
    public byte Byte2;
    [FieldOffset(3)]
    public byte Byte3;
}
class Program
{
    static void Main()
    {
        UnionStruct u = new UnionStruct();
        u.IntValue = 0x12345678;
        Console.WriteLine($"IntValue: 0x{u.IntValue:X8}");
        Console.WriteLine($"FloatValue: {u.FloatValue}");
        Console.WriteLine($"Bytes: {u.Byte0:X2} {u.Byte1:X2} {u.Byte2:X2} {u.Byte3:X2}");
    }
}

IntValue: 0x12345678
FloatValue: 1.5399896E-36
Bytes: 78 56 34 12

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
unsafe struct FixedBufferStruct
{
    public fixed byte Buffer[16];
}
class Program
{
    static unsafe void Main()
    {
        FixedBufferStruct fbs = new FixedBufferStruct();
        for (int i = 0; i < 16; i++)
        {
            fbs.Buffer[i] = (byte)i;
        }
        for (int i = 0; i < 16; i++)
        {
            Console.Write($"{fbs.Buffer[i]} ");
        }
    }
}

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
unsafe struct FixedBufferStruct
{
    public fixed int Buffer[4];
}
class Program
{
    static unsafe void Main()
    {
        FixedBufferStruct fbs = new FixedBufferStruct();
        for (int i = 0; i < 4; i++)
        {
            fbs.Buffer[i] = i * 10;
        }
        Span<int> span = MemoryMarshal.CreateSpan(ref fbs.Buffer[0], 4);
        for (int i = 0; i < span.Length; i++)
        {
            Console.WriteLine($"span[{i}] = {span[i]}");
        }
    }
}

span[0] = 0
span[1] = 10
span[2] = 20
span[3] = 30

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct POINT
{
    public int X;
    public int Y;
}
class Program
{
    [DllImport("user32.dll")]
    static extern bool GetCursorPos(out POINT lpPoint);
    static void Main()
    {
        if (GetCursorPos(out POINT point))
        {
            Console.WriteLine($"カーソル位置: X={point.X}, Y={point.Y}");
        }
        else
        {
            Console.WriteLine("カーソル位置の取得に失敗しました。");
        }
    }
}

カーソル位置: X=1234, Y=567

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct Stat
{
    public ulong st_dev;
    public ulong st_ino;
    public ulong st_nlink;
    public uint st_mode;
    public uint st_uid;
    public uint st_gid;
    public ulong st_rdev;
    public long st_size;
    public long st_blksize;
    public long st_blocks;
    public long st_atime;
    public long st_mtime;
    public long st_ctime;
}
class Program
{
    [DllImport("libc", SetLastError = true)]
    static extern int stat(string path, out Stat buf);
    static void Main()
    {
        if (stat("/etc/passwd", out Stat statBuf) == 0)
        {
            Console.WriteLine($"ファイルサイズ: {statBuf.st_size} バイト");
            Console.WriteLine($"最終更新時刻: {statBuf.st_mtime}");
        }
        else
        {
            Console.WriteLine("stat呼び出しに失敗しました。");
        }
    }
}

ファイルサイズ: 2048 バイト
最終更新時刻: 1625078400

using System;
using System.IO;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct DataRecord
{
    public int Id;
    public short Value;
    public byte Flag;
}
class Program
{
    static void Main()
    {
        DataRecord record = new DataRecord { Id = 1001, Value = 300, Flag = 1 };
        using (var fs = new FileStream("data.bin", FileMode.Create))
        using (var bw = new BinaryWriter(fs))
        {
            bw.Write(record.Id);
            bw.Write(record.Value);
            bw.Write(record.Flag);
        }
        Console.WriteLine("バイナリファイルに書き込み完了");
    }
}

バイナリファイルに書き込み完了

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct DataRecord
{
    public int Id;
    public short Value;
    public byte Flag;
}
class Program
{
    static unsafe void Main()
    {
        DataRecord record = new DataRecord { Id = 1001, Value = 300, Flag = 1 };
        int size = Marshal.SizeOf<DataRecord>();
        byte[] buffer = new byte[size];
        fixed (byte* p = buffer)
        {
            *(DataRecord*)p = record;
        }
        Console.WriteLine($"構造体サイズ: {size} バイト");
        Console.WriteLine("バイト配列内容:");
        foreach (var b in buffer)
        {
            Console.Write($"{b:X2} ");
        }
    }
}

構造体サイズ: 7 バイト
バイト配列内容:
E9 03 00 00 2C 01 01

using System;
using System.Net;
struct NetworkPacket
{
    public ushort Header;
    public uint Data;
}
class Program
{
    static void Main()
    {
        NetworkPacket packet = new NetworkPacket
        {
            Header = 0x1234,
            Data = 0xABCDEF01
        };
        // ホストからネットワークバイトオーダーに変換
        ushort netHeader = (ushort)IPAddress.HostToNetworkOrder((short)packet.Header);
        uint netData = (uint)IPAddress.HostToNetworkOrder((int)packet.Data);
        Console.WriteLine($"ネットワークバイトオーダー Header: 0x{netHeader:X4}");
        Console.WriteLine($"ネットワークバイトオーダー Data: 0x{netData:X8}");
    }
}

ネットワークバイトオーダー Header: 0x3412
ネットワークバイトオーダー Data: 0x01EFCDAB

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct FixedPacket
{
    public byte Command;
    public ushort Length;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
    public byte[] Payload;
}
class Program
{
    static void Main()
    {
        FixedPacket packet = new FixedPacket
        {
            Command = 0x01,
            Length = 4,
            Payload = new byte[] { 0x10, 0x20, 0x30, 0x40 }
        };
        int size = Marshal.SizeOf(packet);
        Console.WriteLine($"パケットサイズ: {size} バイト");
    }
}

パケットサイズ: 7 バイト

using System;
using System.Runtime.InteropServices;
using NUnit.Framework;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct TestStruct
{
    public int Id;
    public short Value;
    public byte Flag;
}
[TestFixture]
public class StructSizeTests
{
    [Test]
    public void TestStructSize_IsExpected()
    {
        int expectedSize = 7; // int(4) + short(2) + byte(1) = 7バイト(Pack=1でパディングなし)
        int actualSize = Marshal.SizeOf<TestStruct>();
        Assert.AreEqual(expectedSize, actualSize, "TestStructのサイズが期待値と異なります。");
    }
}

// 例: [StructSizeCheck(ExpectedSize = 7)] のような属性を定義し、
// Source Generatorが対応するAssertコードを生成するイメージ

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct StructWithRef
{
    public int Id;
    public string Name; // リファレンス型フィールド
}
class Program
{
    static void Main()
    {
        int size = Marshal.SizeOf<StructWithRef>();
        Console.WriteLine($"StructWithRefのサイズ: {size} バイト");
    }
}

StructWithRefのサイズ: 12 バイト

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct StructWithAutoProp
{
    public int Id { get; set; }
    public byte Flag { get; set; }
}
class Program
{
    static void Main()
    {
        int size = Marshal.SizeOf<StructWithAutoProp>();
        Console.WriteLine($"StructWithAutoPropのサイズ: {size} バイト");
    }
}

StructWithAutoPropのサイズ: 8 バイト

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct StructWithPointer
{
    public int Id;
    public IntPtr Ptr; // ポインタ型
}
class Program
{
    static void Main()
    {
        int size = Marshal.SizeOf<StructWithPointer>();
        Console.WriteLine($"StructWithPointerのサイズ: {size} バイト");
    }
}

// イメージ例(実際にはunsafeコードやポインタ操作が必要)
[StructLayout(LayoutKind.Sequential)]
struct VariableLengthStruct
{
    public int Length;
    // 可変長データはここに続くが、C#構造体では表現できない
}

using System;
using System.Runtime.InteropServices;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct SmallStruct
{
    public byte A;
    public byte B;
    public byte C;
}
[StructLayout(LayoutKind.Sequential)]
struct LargeStruct
{
    public int A;
    public int B;
    public int C;
    public int D;
}
public class StructBenchmark
{
    private SmallStruct small = new SmallStruct { A = 1, B = 2, C = 3 };
    private LargeStruct large = new LargeStruct { A = 1, B = 2, C = 3, D = 4 };
    [Benchmark]
    public int SumSmall()
    {
        return small.A + small.B + small.C;
    }
    [Benchmark]
    public int SumLarge()
    {
        return large.A + large.B + large.C + large.D;
    }
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<StructBenchmark>();
    }
}

using System;
ref struct LargeStruct
{
    public int A;
    public int B;
    public int C;
    public int D;
    public int Sum() => A + B + C + D;
}
class Program
{
    static void Process(ref LargeStruct ls)
    {
        Console.WriteLine($"Sum: {ls.Sum()}");
    }
    static void Main()
    {
        LargeStruct ls = new LargeStruct { A = 1, B = 2, C = 3, D = 4 };
        Process(ref ls);
    }
}

Sum: 10

using System;
class Program
{
    static void Main()
    {
        int[] data = { 1, 2, 3, 4, 5 };
        ReadOnlySpan<int> span = data.AsSpan(1, 3); // 2,3,4の部分ビュー
        foreach (var v in span)
        {
            Console.WriteLine(v);
        }
    }
}

2
3
4

using System;
class Program
{
    static (int X, int Y) GetPoint()
    {
        return (10, 20);
    }
    static void Main()
    {
        var point = GetPoint();
        Console.WriteLine($"X: {point.X}, Y: {point.Y}");
    }
}

X: 10, Y: 20

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct Data
{
    public int Id;
    public short Value;
}
class Program
{
    static void Main()
    {
        Data data = new Data { Id = 123, Value = 456 };
        Span<byte> bytes = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref data, 1));
        Console.WriteLine("構造体のバイト列:");
        foreach (var b in bytes)
        {
            Console.Write($"{b:X2} ");
        }
    }
}

構造体のバイト列:
7B 00 00 00 C8 01

using System;
using System.Runtime.CompilerServices;
class Program
{
    static void Main()
    {
        int value = 123456;
        ref byte byteRef = ref Unsafe.As<int, byte>(ref value);
        Console.WriteLine($"最初のバイト: {byteRef:X2}");
    }
}

最初のバイト: 40

// 例: [GenerateSizeCheck] 属性を付けると、
// Source Generatorが以下のようなコードを生成するイメージ
// public static class GeneratedSizeChecks
// {
//     public static void CheckMyStructSize()
//     {
//         const int ExpectedSize = 16;
//         int actualSize = Marshal.SizeOf<MyStruct>();
//         if (actualSize != ExpectedSize)
//             throw new InvalidOperationException("サイズ不一致");
//     }
// }