Как управлять памятью в C#: StructLayout

Привет, Хабр!

Сегодня рассмотрим тему, которая обычно ассоциируется с C или Rust, но никак не с C#. А именно — ручное управление памятью, байтовые смещения, бинарная сериализация и прочая низкоуровневые вещи. Зачем? Допустим, в одном из проектов потребовалось прочитать старый бинарный лог от С-подобной прошивки. Формат документации был: offset 0 — 1 byte: Type; offset 1 — 2 bytes: ID; offset 3 — 4 bytes: Timestamp; и т.д.

Разбирать всё это вручную с BinaryReader? Нет, спасибо. Можно воспользоваться StructLayout, FieldOffset, MemoryMappedFile, Unsafe.As<T>() и Span<byte>.

По умолчанию C# делает всё за нас: размещает поля в структурах, оптимизирует порядок, выравнивает память, добавляет паддинги — и всё это работает чудесно… пока вы не столкнулись с чем-то внешним. Например:

• Нативной DLL на C

• Протоколом, который требует чёткой сериализации

• Memory-mapped файлом со строгим байтовым форматом

• Жёсткими требованиями к zero-GC и zero-copy

В этих случаях вы не можете положиться на LayoutKind.Auto. Нужно явно указать порядок полей и, главное — их байтовое смещение. Для этого в C# есть атрибуты:

[StructLayout(LayoutKind.Sequential, Pack = 1)] // или [StructLayout(LayoutKind.Explicit)]

Sequential и Explicit: в чём разница?

LayoutKind.Sequential говорит CLR: «располагай поля в порядке объявления». Хорошо подходит, когда нужно хотите сохранить порядок и не хотите паддингов. Но не получится вручную указать смещения.

LayoutKind.Explicit даёт абсолютный контроль: вы сами указываете, на каком смещении должно быть каждое поле. Это мощно, но требует некой точности.

Пример:

[StructLayout(LayoutKind.Explicit)] struct PacketHeader {     [FieldOffset(0)] public byte Version;     [FieldOffset(1)] public byte Flags;     [FieldOffset(2)] public ushort Length;     [FieldOffset(4)] public uint Checksum; }

Если байты из файла или по сети приходят именно в этом порядке — такая структура отработает идеально. Но как это применить?

Читаем бинарный блок напрямую как структуру

Допустим, есть бинарный файл packet.bin, в котором каждый блок данных представляет собой наш PacketHeader.

Вот как можно спроецировать байты файла прямо в структуру:

byte[] rawBytes = File.ReadAllBytes("packet.bin");  GCHandle handle = GCHandle.Alloc(rawBytes, GCHandleType.Pinned); PacketHeader header = Marshal.PtrToStructure<PacketHeader>(handle.AddrOfPinnedObject()); handle.Free();

GCHandle.Alloc: закрепляем массив в памяти, чтобы GC не сдвинул его во время чтения. Marshal.PtrToStructure<T>(): интерпретируем указатель на массив как структуру T.

После чтения освобождаем handle, чтобы не держать память зря.

Unsafe.As() и Span

Если хочется максимальной производительности, без маршала и GC — есть System.Runtime.CompilerServices.Unsafe.

public static T ReadStruct<T>(Span<byte> data) where T : unmanaged {     return Unsafe.As<byte, T>(ref data[0]); }

Теперь можно читать структуру напрямую из любого источника, даже из stackalloc, Span<byte> или MemoryMappedFile.

Span<byte> span = stackalloc byte[sizeof(PacketHeader)]; ReadFromSocket(span); // читаем напрямую в span  PacketHeader header = ReadStruct<PacketHeader>(span);

T должен быть unmanaged. Размер span должен быть равен sizeof(T).

Разбираем StructLayout в контексте interop

Допустим, есть внешняя DLL, которая принимает указатель на структуру. Прототип на C:

typedef struct {     int id;     float temperature;     char status; } SensorData;

На C# стороне:

[StructLayout(LayoutKind.Sequential, Pack = 1)] struct SensorData {     public int Id;     public float Temperature;     public byte Status; }

И вызов:

[DllImport("libsensor.so")] static extern void ProcessSensor(ref SensorData data);

Если вы не используете Pack = 1, то CLR может вставить паддинги между float и byte, и ваша структура станет несовместимой. Результат — UB или поломанные данные.

MemoryMappedFile: структура прямо из файла

Если есть огромный файл и не хочется загружать его целиком — используйте MemoryMappedFile. Это позволяет обращаться к файлу как к памяти, и считывать структуры напрямую.

using var mmf = MemoryMappedFile.CreateFromFile("log.dat", FileMode.Open); using var accessor = mmf.CreateViewAccessor(0, sizeof(PacketHeader), MemoryMappedFileAccess.Read);  unsafe {     byte* ptr = null;     accessor.SafeMemoryMappedViewHandle.AcquirePointer(ref ptr);      // интерпретируем указатель как структуру     var header = Unsafe.AsRef<PacketHeader>(ptr);      Console.WriteLine($"Length = {header.Length}");      accessor.SafeMemoryMappedViewHandle.ReleasePointer(); }

Это zero-copy, high-speed и zero-GC. Но будьте внимательны: ошибки в выравнивании и доступе — ваши, и только ваши.

Выравнивание и паддинги

Вот так выглядит типичная ловушка:

struct Foo {     public byte A;     public int B; }

Кажется, размер должен быть 5 байт. Но CLR выравнивает int по 4-байтовой границе, поэтому sizeof(Foo) = 8.

Чтобы избежать этого:

[StructLayout(LayoutKind.Sequential, Pack = 1)] struct FooTight {     public byte A;     public int B; // теперь сразу за A }

Но не переусердствуйте. Неправильное выравнивание — это:

• медленно на некоторых архитектурах

• может привести к AccessViolationException на ARM

Работа с Endianness — не забываем

.NET — little-endian. Но если вы читаете big-endian поток (а такие до сих пор везде), придётся свапать байты вручную:

public static ushort ReadUInt16BigEndian(Span<byte> data) {     return (ushort)((data[0] << 8) | data[1]); } 

Или через BinaryPrimitives:

ushort value = BinaryPrimitives.ReadUInt16BigEndian(data);

В Unsafe.As<T>() это не поможет — там байты идут как есть, поэтому endianness нужно контролировать до вызова.

Бинарный лог с embedded-устройства

Устройство пишет лог в файл. Каждая запись — 12 байт. Формат:

• uint16 Header (BigEndian) — всегда 0xAA55, начало записи

• byte SensorId — ID датчика

• byte Flags — побитовые флаги состояния

• float Value — измеренное значение

• uint32 Timestamp — время в секундах UnixTime

Нужно:

• Прочитать лог

• Провалидировать данные

• Отобразить как C#-объекты

• Обратно сериализовать

Структура в памяти

[StructLayout(LayoutKind.Explicit, Size = 12)] public struct TelemetryRecordRaw {     [FieldOffset(0)] public ushort HeaderBE;     [FieldOffset(2)] public byte SensorId;     [FieldOffset(3)] public byte Flags;     [FieldOffset(4)] public float ValueLE;     [FieldOffset(8)] public uint TimestampLE; }

Отображает байты как есть. Используем LayoutKind.Explicit, чтобы задать смещения.

Высокоуровневая модель

public class TelemetryRecord {     public byte SensorId { get; set; }     public byte Flags { get; set; }     public float Value { get; set; }     public DateTime Timestamp { get; set; } }

Класс для логики: удобнее работать, анализировать, сериализовать в JSON и т.д.

Парсинг записи из байтов

public static bool TryParse(ReadOnlySpan<byte> span, out TelemetryRecord record) {     record = null;     if (span.Length < 12) return false;      var raw = MemoryMarshal.Read<TelemetryRecordRaw>(span); // zero-copy чтение      if (BinaryPrimitives.ReverseEndianness(raw.HeaderBE) != 0xAA55) return false; // валидация      record = new TelemetryRecord     {         SensorId = raw.SensorId,         Flags = raw.Flags,         Value = raw.ValueLE, // float уже в little-endian         Timestamp = DateTimeOffset.FromUnixTimeSeconds(raw.TimestampLE).DateTime     };      return true; }

Конвертируем ushort из BigEndian, парсим float, uint напрямую.

Обратная сериализация

public static byte[] Serialize(TelemetryRecord record) {     var raw = new TelemetryRecordRaw     {         HeaderBE = BinaryPrimitives.ReverseEndianness(0xAA55),         SensorId = record.SensorId,         Flags = record.Flags,         ValueLE = record.Value,         TimestampLE = (uint)new DateTimeOffset(record.Timestamp).ToUnixTimeSeconds()     };      byte[] result = new byte[12];     MemoryMarshal.Write(result, ref raw); // запись как struct → bytes     return result; }

Сохраняем структуру в byte[], endianness учитываем вручную.

Чтение всех записей из файла

public static IEnumerable<TelemetryRecord> ParseLogFile(string path) {     var bytes = File.ReadAllBytes(path);     for (int i = 0; i + 12 <= bytes.Length; i += 12)     {         var slice = new ReadOnlySpan<byte>(bytes, i, 12);         if (TryParse(slice, out var record))             yield return record;     } }

Читаем файл блоками по 12 байт, парсим каждую запись, отдаём как TelemetryRecord.

Пример использования

foreach (var record in ParseLogFile("telemetry.bin")) {     Console.WriteLine($"Sensor: {record.SensorId}, Value: {record.Value:F2}, Time: {record.Timestamp}"); }

Выводим результат:

Sensor: 1, Value: 23.57, Time: 2025-04-01 14:23:45 Sensor: 2, Value: 18.02, Time: 2025-04-01 14:23:50 Sensor: 1, Value: 24.03, Time: 2025-04-01 14:23:55 Sensor: 3, Value: 19.76, Time: 2025-04-01 14:24:00 Sensor: 2, Value: 17.91, Time: 2025-04-01 14:24:05

Каждая строка — это одна запись из бинарного лога:

• SensorId — номер датчика

• Value — измеренное значение (температура, давление и т.д.)

• Timestamp — дата и время, преобразованные из UnixTime

Вывод читаемый, логически структурирован, не требует постобработки, и может идти прямо в аналитическую систему, БД или отображаться в UI.

---

Делитесь в комментариях своими кейсами: где вы использовали ручное управление памятью и с чем пришлось побороться.

Если близки темы низкоуровневой работы с памятью и хочется больше практики — присоединяйтесь к открытым урокам по C# в Otus. Разберём реальные задачи, где важны производительность, контроль над ресурсами и архитектурный подход:

• 8 апреля — Используем C# для построения консольного интерфейса. Подробнее

• 21 апреля — Анализ сложности алгоритмов и сортировка. Подробнее