Cara mengonversi objek menjadi array byte di C #

Saya memiliki koleksi objek yang perlu saya tulis ke file biner.

Saya membutuhkan byte dalam file agar kompak, jadi saya tidak bisa menggunakan BinaryFormatter. BinaryFormattermelempar semua jenis info untuk kebutuhan deserialization.

Jika saya mencoba

byte[] myBytes = (byte[]) myObject 

Saya mendapatkan pengecualian waktu proses.

Saya membutuhkan ini untuk menjadi cepat jadi saya lebih suka tidak menyalin array byte sekitar. Saya hanya ingin pemerannya byte[] myBytes = (byte[]) myObjectbekerja!

OK untuk memperjelas, saya tidak dapat memiliki metadata apa pun di file keluaran. Hanya byte objek. Paket objek-ke-objek. Berdasarkan jawaban yang diterima, sepertinya saya akan menulis Buffer.BlockCopykode tingkat rendah . Mungkin menggunakan kode yang tidak aman.

Untuk mengonversi objek menjadi array byte:

// 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();
    }
}

Anda hanya perlu menyalin fungsi ini ke kode Anda dan mengirimkannya objek yang perlu Anda ubah menjadi array byte. Jika Anda perlu mengubah array byte menjadi objek lagi, Anda dapat menggunakan fungsi di bawah ini:

// 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;
    }
}

Anda dapat menggunakan fungsi ini dengan kelas khusus. Anda hanya perlu menambahkan [Serializable]atribut di kelas Anda untuk mengaktifkan serialisasi

Jika Anda ingin data serial benar-benar ringkas, Anda dapat menulis metode serialisasi sendiri. Dengan begitu Anda akan memiliki biaya overhead minimum.

Contoh:

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;
   }

}

Nah cor dari myObjectke byte[]tidak akan pernah bekerja kecuali Anda punya konversi eksplisit atau jika myObject adalah sebuah byte[]. Anda memerlukan kerangka serialisasi dari beberapa jenis. Ada banyak hal di luar sana, termasuk Protocol Buffer yang dekat dan saya sayangi. Ini cukup "ramping dan berarti" dalam hal ruang dan waktu.

Anda akan menemukan bahwa hampir semua framework serialisasi memiliki batasan signifikan pada apa yang dapat Anda serialisasi, namun - Protocol Buffer lebih dari beberapa, karena bersifat lintas platform.

Jika Anda dapat memberikan lebih banyak persyaratan, kami dapat membantu Anda lebih lanjut - tetapi tidak akan pernah semudah mentransmisikan ...

EDIT: Hanya untuk menanggapi ini:

Saya membutuhkan file biner saya untuk memuat byte objek. Hanya byte, tidak ada metadata apa pun. Paket objek-ke-objek. Jadi saya akan menerapkan serialisasi kustom.

Harap diingat bahwa byte dalam objek Anda cukup sering menjadi referensi ... jadi Anda harus mencari tahu apa yang harus dilakukan dengannya.

Saya menduga Anda akan menemukan bahwa merancang dan menerapkan kerangka kerja serialisasi khusus Anda sendiri lebih sulit daripada yang Anda bayangkan.

Saya pribadi akan merekomendasikan bahwa jika Anda hanya perlu melakukan ini untuk beberapa jenis tertentu, Anda tidak perlu repot-repot mencoba membuat kerangka serialisasi umum. Cukup terapkan metode instance dan metode statis di semua jenis yang Anda butuhkan:

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

Satu hal yang perlu diingat: semuanya menjadi lebih rumit jika Anda melibatkan warisan. Tanpa pewarisan, jika Anda tahu jenis yang Anda gunakan untuk memulai, Anda tidak perlu menyertakan informasi jenis apa pun. Tentu saja, ada juga masalah pembuatan versi - apakah Anda perlu khawatir tentang kompatibilitas mundur dan maju dengan berbagai versi tipe Anda?

Saya mengambil jawaban Crystalonics dan mengubahnya menjadi metode penyuluhan. Saya berharap orang lain akan menganggapnya berguna:

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;
    }
}

Anda benar-benar berbicara tentang serialisasi, yang dapat memiliki banyak bentuk. Karena Anda menginginkan yang kecil dan biner, penyangga protokol dapat menjadi pilihan yang layak - memberikan toleransi versi dan portabilitas juga. Tidak seperti BinaryFormatter, format kawat buffer protokol tidak menyertakan semua jenis metadata; hanya penanda yang sangat singkat untuk mengidentifikasi data.

Di NET. Ada beberapa implementasi; khususnya

• protobuf-net
• dotnet-protobufs

Saya dengan rendah hati berpendapat bahwa protobuf-net (yang saya tulis) memungkinkan lebih banyak penggunaan .NET-idiomatik dengan kelas C # yang khas (buffer protokol "biasa" cenderung menuntut pembuatan kode); sebagai contoh:

[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);

Ini berhasil untuk saya:

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

foo adalah Objek yang saya yakin 100% adalah array byte.

Lihatlah Serialization , teknik untuk "mengubah" seluruh objek menjadi aliran byte. Anda dapat mengirimkannya ke jaringan atau menuliskannya menjadi sebuah file dan kemudian mengembalikannya kembali ke suatu objek nanti.

Saya menemukan cara lain untuk mengonversi objek menjadi byte [], inilah solusi saya:

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

Salam

Untuk mengakses memori suatu objek secara langsung (untuk melakukan "core dump"), Anda harus membuka kode yang tidak aman.

Jika Anda menginginkan sesuatu yang lebih ringkas daripada yang diberikan BinaryWriter atau yang diberikan oleh raw memory dump, maka Anda perlu menulis beberapa kode serialisasi khusus yang mengekstrak informasi penting dari objek dan mengemasnya secara optimal.

edit PS Sangat mudah untuk menggabungkan pendekatan BinaryWriter ke dalam DeflateStream untuk memampatkan data, yang biasanya akan mengurangi setengah ukuran data.

Saya percaya apa yang Anda coba lakukan tidak mungkin.

Sampah yang BinaryFormatterdibuat diperlukan untuk memulihkan objek dari file setelah program Anda dihentikan.
Bagaimanapun juga mungkin untuk mendapatkan data objek, Anda hanya perlu mengetahui ukuran pastinya (lebih sulit daripada kedengarannya):

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;
}

ini dapat dipulihkan melalui:

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

Alasan mengapa metode di atas tidak berfungsi untuk serialisasi adalah karena empat byte pertama dalam data yang dikembalikan sesuai dengan a RuntimeTypeHandle. The RuntimeTypeHandlemenggambarkan tata letak / jenis objek tetapi nilai itu berubah setiap kali program ini adalah berlari.

EDIT: itu bodoh, jangan lakukan itu -> Jika Anda sudah mengetahui jenis objek yang akan dideserialisasi dengan pasti, Anda dapat mengganti byte tersebut BitConvertes.GetBytes((int)typeof(yourtype).TypeHandle.Value)pada saat deserialisasi.