Как преобразовать объект в байтовый массив в C #

У меня есть набор объектов, которые мне нужно записать в двоичный файл.

Мне нужно, чтобы байты в файле были компактными, поэтому я не могу их использовать BinaryFormatter. BinaryFormatterдобавляет всевозможную информацию для нужд десериализации.

Если я попробую

byte[] myBytes = (byte[]) myObject 

Я получаю исключение во время выполнения.

Мне нужно, чтобы это было быстро, поэтому я бы предпочел не копировать массивы байтов. Я просто хочу, чтобы актеры byte[] myBytes = (byte[]) myObjectпоработали!

Хорошо, чтобы было ясно, у меня не может быть никаких метаданных в выходном файле. Просто байты объекта. Упакованный объект-объект. Судя по полученным ответам, похоже, что я буду писать низкоуровневый Buffer.BlockCopyкод. Возможно, используется небезопасный код.

Чтобы преобразовать объект в байтовый массив:

// Convert an object to a byte array
public static byte[] ObjectToByteArray(Object obj)
{
    BinaryFormatter bf = new BinaryFormatter();
    using (var ms = new MemoryStream())
    {
        bf.Serialize(ms, obj);
        return ms.ToArray();
    }
}

Вам просто нужно скопировать эту функцию в свой код и отправить ей объект, который нужно преобразовать в массив байтов. Если вам нужно снова преобразовать массив байтов в объект, вы можете использовать функцию ниже:

// Convert a byte array to an Object
public static Object ByteArrayToObject(byte[] arrBytes)
{
    using (var memStream = new MemoryStream())
    {
        var binForm = new BinaryFormatter();
        memStream.Write(arrBytes, 0, arrBytes.Length);
        memStream.Seek(0, SeekOrigin.Begin);
        var obj = binForm.Deserialize(memStream);
        return obj;
    }
}

Вы можете использовать эти функции с пользовательскими классами. Вам просто нужно добавить [Serializable]атрибут в свой класс, чтобы включить сериализацию

Если вы хотите, чтобы сериализованные данные были действительно компактными, вы можете сами написать методы сериализации. Таким образом у вас будет минимум накладных расходов.

Пример:

public class MyClass {

   public int Id { get; set; }
   public string Name { get; set; }

   public byte[] Serialize() {
      using (MemoryStream m = new MemoryStream()) {
         using (BinaryWriter writer = new BinaryWriter(m)) {
            writer.Write(Id);
            writer.Write(Name);
         }
         return m.ToArray();
      }
   }

   public static MyClass Desserialize(byte[] data) {
      MyClass result = new MyClass();
      using (MemoryStream m = new MemoryStream(data)) {
         using (BinaryReader reader = new BinaryReader(m)) {
            result.Id = reader.ReadInt32();
            result.Name = reader.ReadString();
         }
      }
      return result;
   }

}

Ну отливка из myObjectк byte[]никогда не будет работать , если вы не получили явное преобразование или , если myObject этоbyte[] . Вам нужна сериализация рамка какого - то. Их много, в том числе Protocol Buffers, который мне близок и дорог. Он довольно «скудный и скупой» как с точки зрения пространства, так и времени.

Однако вы обнаружите, что почти все фреймворки сериализации имеют значительные ограничения на то, что вы можете сериализовать - буферы протоколов больше, чем некоторые, из-за кросс-платформенности.

Если вы можете указать больше требований, мы сможем помочь вам больше - но это никогда не будет так просто, как кастинг ...

РЕДАКТИРОВАТЬ: просто чтобы ответить на это:

Мне нужен мой двоичный файл, чтобы содержать байты объекта. Только байты, никаких метаданных. Упакованный объект-объект. Поэтому я буду реализовывать настраиваемую сериализацию.

Помните, что байты в ваших объектах довольно часто являются ссылками ... поэтому вам нужно решить, что с ними делать.

Я подозреваю, что вы обнаружите, что разработать и реализовать собственную структуру сериализации сложнее, чем вы думаете.

Я бы лично порекомендовал, если вам нужно сделать это только для нескольких конкретных типов, вы не пытаетесь придумать общую структуру сериализации. Просто реализуйте метод экземпляра и статический метод для всех необходимых вам типов:

public void WriteTo(Stream stream)
public static WhateverType ReadFrom(Stream stream)

Следует помнить об одном: все становится сложнее, если у вас есть наследство. Без наследования, если вы знаете, с какого типа вы начинаете, вам не нужно включать какую-либо информацию о типе. Конечно, существует также вопрос управления версиями - нужно ли вам беспокоиться об обратной и прямой совместимости с различными версиями ваших типов?

Я взял ответ Crystalonics и превратил их в методы расширения. Надеюсь, кому-то они пригодятся:

public static byte[] SerializeToByteArray(this object obj)
{
    if (obj == null)
    {
        return null;
    }
    var bf = new BinaryFormatter();
    using (var ms = new MemoryStream())
    {
        bf.Serialize(ms, obj);
        return ms.ToArray();
    }
}

public static T Deserialize<T>(this byte[] byteArray) where T : class
{
    if (byteArray == null)
    {
        return null;
    }
    using (var memStream = new MemoryStream())
    {
        var binForm = new BinaryFormatter();
        memStream.Write(byteArray, 0, byteArray.Length);
        memStream.Seek(0, SeekOrigin.Begin);
        var obj = (T)binForm.Deserialize(memStream);
        return obj;
    }
}

Вы действительно говорите о сериализации, которая может принимать разные формы. Поскольку вам нужны небольшие и двоичные файлы, буферы протоколов могут быть жизнеспособным вариантом, обеспечивающим также устойчивость к версиям и переносимость. В отличие от этого BinaryFormatter, формат проводных буферов протокола не включает все метаданные типа; просто очень краткие маркеры для идентификации данных.

В .NET есть несколько реализаций; особенно

• protobuf-net
• dotnet-protobufs

Я смиренно утверждаю, что protobuf-net (который я написал) допускает большее количество .NET-идиоматического использования с типичными классами C # («обычные» буферы протоколов обычно требуют генерации кода); например:

[ProtoContract]
public class Person {
   [ProtoMember(1)]
   public int Id {get;set;}
   [ProtoMember(2)]
   public string Name {get;set;}
}
....
Person person = new Person { Id = 123, Name = "abc" };
Serializer.Serialize(destStream, person);
...
Person anotherPerson = Serializer.Deserialize<Person>(sourceStream);

Это сработало для меня:

byte[] bfoo = (byte[])foo;

foo - это объект, в котором я на 100% уверен, что это массив байтов.

Взгляните на сериализацию , метод «преобразования» всего объекта в поток байтов. Вы можете отправить его в сеть или записать в файл, а затем восстановить его обратно в объект позже.

Я нашел другой способ преобразовать объект в byte [], вот мое решение:

IEnumerable en = (IEnumerable) myObject;
byte[] myBytes = en.OfType<byte>().ToArray();

С уважением

Чтобы получить доступ к памяти объекта напрямую (чтобы сделать «дамп ядра»), вам нужно обратиться к небезопасному коду.

Если вы хотите что-то более компактное, чем BinaryWriter, или необработанный дамп памяти, то вам нужно написать некоторый настраиваемый код сериализации, который извлекает критическую информацию из объекта и упаковывает ее оптимальным образом.

изменить PS Очень легко обернуть подход BinaryWriter в DeflateStream для сжатия данных, что обычно примерно вдвое уменьшает размер данных.

Я считаю, что то, что вы пытаетесь сделать, невозможно.

Создаваемый мусор BinaryFormatterнеобходим для восстановления объекта из файла после остановки вашей программы.
Однако получить данные об объекте можно, вам просто нужно знать его точный размер (сложнее, чем кажется):

public static unsafe byte[] Binarize(object obj, int size)
{
    var r = new byte[size];
    var rf = __makeref(obj);
    var a = **(IntPtr**)(&rf);
    Marshal.Copy(a, r, 0, size);
    return res;
}

это можно восстановить с помощью:

public unsafe static dynamic ToObject(byte[] bytes)
{
    var rf = __makeref(bytes);
    **(int**)(&rf) += 8;
    return GCHandle.Alloc(bytes).Target;
}

Причина, по которой вышеуказанные методы не работают для сериализации, заключается в том, что первые четыре байта возвращаемых данных соответствуют файлу RuntimeTypeHandle. RuntimeTypeHandleОписывает макет / тип объекта , но значение его меняется каждый раз , когда программа побежал.

РЕДАКТИРОВАТЬ: это глупо, не делайте этого -> Если вы уже знаете тип объекта, который нужно десериализовать, вы можете переключать эти байты BitConvertes.GetBytes((int)typeof(yourtype).TypeHandle.Value)во время десериализации.