Saya sedang menulis koneksi TCP prototipe dan saya mengalami beberapa kesulitan menyeragamkan data yang akan dikirim.

Saat ini, saya tidak mengirim apa pun kecuali string, tetapi di masa depan kami ingin dapat mengirim objek apa pun.

Kode ini cukup sederhana saat ini, karena saya pikir semuanya dapat dilemparkan ke dalam array byte:

void SendData(object headerObject, object bodyObject)
{
  byte[] header = (byte[])headerObject;  //strings at runtime, 
  byte[] body = (byte[])bodyObject;      //invalid cast exception

  // Unable to cast object of type 'System.String' to type 'System.Byte[]'.
  ...
}

Ini tentu saja cukup mudah diselesaikan dengan

if( state.headerObject is System.String ){...}

Masalahnya adalah, jika saya melakukannya dengan cara itu, saya perlu memeriksa SETIAP jenis objek yang tidak dapat dilemparkan ke byte [] saat runtime.

Karena saya tidak tahu setiap objek yang tidak dapat dilemparkan ke byte [] pada saat runtime, ini sebenarnya bukan pilihan.

Bagaimana cara mengubah objek apa pun menjadi array byte di C # .NET 4.0?

Gunakan BinaryFormatter:

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

Perhatikan bahwa objdan semua properti / bidang dalam obj(dan seterusnya untuk semua properti / bidangnya) semua harus ditandai dengan Serializableatribut agar berhasil diserialisasi dengan ini.

checkout artikel ini: http://www.morgantechspace.com/2013/08/convert-object-to-byte-array-and-vice.html

Gunakan kode di bawah ini

// Convert an object to a byte array
private byte[] ObjectToByteArray(Object obj)
{
    if(obj == null)
        return null;

    BinaryFormatter bf = new BinaryFormatter();
    MemoryStream ms = new MemoryStream();
    bf.Serialize(ms, obj);

    return ms.ToArray();
}

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

    return obj;
}

Seperti orang lain katakan sebelumnya, Anda bisa menggunakan serialisasi biner, tetapi mungkin menghasilkan byte tambahan atau deserialized menjadi objek dengan data yang tidak persis sama. Menggunakan refleksi di sisi lain cukup rumit dan sangat lambat. Ada solusi lain yang secara ketat dapat mengkonversi objek Anda menjadi byte dan sebaliknya - marshalling:

var size = Marshal.SizeOf(your_object);
// Both managed and unmanaged buffers required.
var bytes = new byte[size];
var ptr = Marshal.AllocHGlobal(size);
// Copy object byte-to-byte to unmanaged memory.
Marshal.StructureToPtr(your_object, ptr, false);
// Copy data from unmanaged memory to managed buffer.
Marshal.Copy(ptr, bytes, 0, size);
// Release unmanaged memory.
Marshal.FreeHGlobal(ptr);

Dan untuk mengonversi byte ke objek:

var bytes = new byte[size];
var ptr = Marshal.AllocHGlobal(size);
Marshal.Copy(bytes, 0, ptr, size);
var your_object = (YourType)Marshal.PtrToStructure(ptr, typeof(YourType));
Marshal.FreeHGlobal(ptr);

Terlihat lebih lambat dan sebagian tidak aman untuk menggunakan pendekatan ini untuk objek dan struct kecil dibandingkan dengan bidang serialisasi Anda sendiri berdasarkan bidang (karena penyalinan ganda dari / ke memori yang tidak dikelola), tetapi cara termudah untuk secara ketat mengkonversi objek ke byte [] tanpa menerapkan serialisasi dan tanpa atribut [Serializable].

Apa yang Anda cari adalah serialisasi. Ada beberapa bentuk serialisasi yang tersedia untuk platform .Net

• Serialisasi Binary
• Serialisasi XML: Menghasilkan string yang mudah dikonversi menjadi byte[]
• ProtoBuffers

public static class SerializerDeserializerExtensions
{
    public static byte[] Serializer(this object _object)
    {   
        byte[] bytes;
        using (var _MemoryStream = new MemoryStream())
        {
            IFormatter _BinaryFormatter = new BinaryFormatter();
            _BinaryFormatter.Serialize(_MemoryStream, _object);
            bytes = _MemoryStream.ToArray();
        }
        return bytes;
    }

    public static T Deserializer<T>(this byte[] _byteArray)
    {   
        T ReturnValue;
        using (var _MemoryStream = new MemoryStream(_byteArray))
        {
            IFormatter _BinaryFormatter = new BinaryFormatter();
            ReturnValue = (T)_BinaryFormatter.Deserialize(_MemoryStream);    
        }
        return ReturnValue;
    }
}

Anda dapat menggunakannya seperti kode di bawah ini.

DataTable _DataTable = new DataTable();
_DataTable.Columns.Add(new DataColumn("Col1"));
_DataTable.Columns.Add(new DataColumn("Col2"));
_DataTable.Columns.Add(new DataColumn("Col3"));

for (int i = 0; i < 10; i++) {
    DataRow _DataRow = _DataTable.NewRow();
    _DataRow["Col1"] = (i + 1) + "Column 1";
    _DataRow["Col2"] = (i + 1) + "Column 2";
    _DataRow["Col3"] = (i + 1) + "Column 3";
    _DataTable.Rows.Add(_DataRow);
}

byte[] ByteArrayTest =  _DataTable.Serializer();
DataTable dt = ByteArrayTest.Deserializer<DataTable>();

Menggunakan Encoding.UTF8.GetByteslebih cepat daripada menggunakan MemoryStream. Di sini, saya menggunakan NewtonsoftJson untuk mengkonversi objek input ke string JSON dan kemudian mendapatkan byte dari string JSON.

byte[] SerializeObject(object value) =>Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(value));

Benchmark untuk versi @Daniel DiPaolo dengan versi ini

Method                    |     Mean |     Error |    StdDev |   Median |  Gen 0 | Allocated |
--------------------------|----------|-----------|-----------|----------|--------|-----------| 
ObjectToByteArray         | 4.983 us | 0.1183 us | 0.2622 us | 4.887 us | 0.9460 |    3.9 KB |
ObjectToByteArrayWithJson | 1.548 us | 0.0309 us | 0.0690 us | 1.528 us | 0.3090 |   1.27 KB |

Solusi Gabungan di kelas Ekstensi:

public static class Extensions {

    public static byte[] ToByteArray(this object obj) {
        var size = Marshal.SizeOf(data);
        var bytes = new byte[size];
        var ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(data, ptr, false);
        Marshal.Copy(ptr, bytes, 0, size);
        Marshal.FreeHGlobal(ptr);
        return bytes;
   }

    public static string Serialize(this object obj) {
        return JsonConvert.SerializeObject(obj);
   }

}

Anda bisa menggunakan alat serialisasi built-in dalam framework dan membuat serial ke MemoryStream . Ini mungkin opsi yang paling mudah, tetapi mungkin menghasilkan byte yang lebih besar [] daripada yang diperlukan untuk skenario Anda.

Jika itu masalahnya, Anda bisa menggunakan refleksi untuk beralih pada bidang dan / atau properti dalam objek yang akan diserialkan dan secara manual menuliskannya ke MemoryStream, memanggil serialisasi secara rekursif jika diperlukan untuk membuat serial jenis non-sepele. Metode ini lebih kompleks dan akan membutuhkan lebih banyak waktu untuk diterapkan, tetapi memungkinkan Anda lebih banyak mengontrol aliran serial.

Bagaimana dengan hal sederhana seperti ini?

return ((object[])value).Cast<byte>().ToArray(); 

Saya lebih suka menggunakan ekspresi "serialisasi" daripada "casting ke byte". Membuat serial objek berarti mengubahnya menjadi array byte (atau XML, atau yang lain) yang dapat digunakan pada kotak jauh untuk membangun kembali objek. Di .NET, Serializableatribut menandai tipe objek yang dapat diserialisasi.

Cara alternatif untuk mengubah objek ke byte array:

TypeConverter objConverter = TypeDescriptor.GetConverter(objMsg.GetType());
byte[] data = (byte[])objConverter.ConvertTo(objMsg, typeof(byte[]));

Satu implementasi tambahan, yang menggunakan JSON biner Newtonsoft.Json dan tidak perlu menandai semuanya dengan atribut [Serializable]. Hanya satu kelemahan adalah bahwa suatu objek harus dibungkus dalam kelas anonim, sehingga array byte yang diperoleh dengan serialisasi biner dapat berbeda dari yang satu ini.

public static byte[] ConvertToBytes(object obj)
{
    using (var ms = new MemoryStream())
    {
        using (var writer = new BsonWriter(ms))
        {
            var serializer = new JsonSerializer();
            serializer.Serialize(writer, new { Value = obj });
            return ms.ToArray();
        }
    }
}

Kelas anonim digunakan karena BSON harus dimulai dengan kelas atau array. Saya belum mencoba deserialize byte [] kembali ke objek dan tidak yakin apakah itu berfungsi, tetapi telah menguji kecepatan konversi ke byte [] dan itu benar-benar memuaskan kebutuhan saya.

Bagaimana dengan serialisasi? lihat di sini .