Tôi đang viết một kết nối TCP nguyên mẫu và tôi gặp một số khó khăn khi đồng nhất hóa dữ liệu được gửi.

Hiện tại, tôi không gửi gì ngoài chuỗi, nhưng trong tương lai chúng tôi muốn có thể gửi bất kỳ đối tượng nào.

Mã hiện tại khá đơn giản, vì tôi nghĩ mọi thứ có thể được chuyển thành một mảng 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[]'.
  ...
}

Điều này tất nhiên là đủ dễ dàng giải quyết với một

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

Vấn đề là, nếu tôi làm theo cách đó, tôi cần kiểm tra MỌI loại đối tượng không thể chuyển thành byte [] khi chạy.

Vì tôi không biết mọi đối tượng không thể chuyển thành byte [] khi chạy, đây thực sự không phải là một tùy chọn.

Làm thế nào để chuyển đổi bất kỳ đối tượng nào thành một mảng byte trong C # .NET 4.0?

Sử dụng 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();
    }
}

Lưu ý rằng objvà bất kỳ thuộc tính / trường nào trong obj(và tương tự cho tất cả các thuộc tính / trường của chúng) đều sẽ cần phải được gắn thẻ với Serializablethuộc tính để được nối tiếp thành công với điều này.

kiểm tra bài viết này: http://www.morgantechspace.com/2013/08/convert-object-to-byte-array-and-vice.html

Sử dụng mã dưới đây

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

Giống như những người khác đã nói trước đây, bạn có thể sử dụng tuần tự nhị phân, nhưng nó có thể tạo ra một byte bổ sung hoặc được giải tuần tự hóa thành một đối tượng không có cùng dữ liệu. Sử dụng sự phản chiếu mặt khác là khá phức tạp và rất chậm. Có một giải pháp khác có thể chuyển đổi nghiêm ngặt các đối tượng của bạn thành byte và vise-Versa - 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);

Và để chuyển đổi byte thành đối tượng:

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

Việc sử dụng phương pháp này cho các đối tượng và cấu trúc nhỏ so với trường tuần tự hóa của bạn theo trường (do sao chép hai lần từ / sang bộ nhớ không được quản lý), nhưng cách dễ nhất là chuyển đổi đối tượng thành byte [] mà không thực hiện tuần tự hóa và không có thuộc tính [Nối tiếp].

Những gì bạn đang tìm kiếm là serialization. Có một số hình thức tuần tự hóa có sẵn cho nền tảng .Net

• Tuần tự nhị phân
• Tuần tự hóa XML: Tạo ra một chuỗi có thể dễ dàng chuyển đổi thành một 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;
    }
}

Bạn có thể sử dụng nó như mã dưới đây.

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

Sử dụng Encoding.UTF8.GetBytesnhanh hơn sử dụng MemoryStream. Ở đây, tôi đang sử dụng NewtonsoftJson để chuyển đổi đối tượng đầu vào thành chuỗi JSON và sau đó nhận byte từ chuỗi JSON.

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

Điểm chuẩn cho phiên bản của @Daniel DiPaolo với phiên bản này

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 |

Giải pháp kết hợp trong lớp Tiện ích mở rộng:

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

}

Bạn có thể sử dụng các công cụ tuần tự hóa tích hợp trong khung và tuần tự hóa thành MemoryStream . Đây có thể là tùy chọn đơn giản nhất, nhưng có thể tạo ra một byte lớn hơn [] có thể rất cần thiết cho kịch bản của bạn.

Nếu đó là trường hợp, bạn có thể sử dụng sự phản chiếu để lặp lại các trường và / hoặc các thuộc tính trong đối tượng được tuần tự hóa và viết chúng theo cách thủ công vào MemoryStream, gọi tuần tự theo cách đệ quy nếu cần để tuần tự hóa các loại không tầm thường. Phương pháp này phức tạp hơn và sẽ mất nhiều thời gian hơn để thực hiện, nhưng cho phép bạn kiểm soát nhiều hơn đối với luồng được tuần tự hóa.

Làm thế nào về một cái gì đó đơn giản như thế này?

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

Tôi thà sử dụng biểu thức "tuần tự hóa" hơn là "truyền thành byte". Tuần tự hóa một đối tượng có nghĩa là chuyển đổi nó thành một mảng byte (hoặc XML hoặc một cái gì khác) có thể được sử dụng trên hộp từ xa để xây dựng lại đối tượng. Trong .NET, các Serializablethuộc tính đánh dấu các loại có đối tượng có thể được tuần tự hóa.

Cách khác để chuyển đổi đối tượng thành mảng byte:

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

Một triển khai bổ sung, sử dụng JSON nhị phân Newtonsoft.Json và không yêu cầu đánh dấu mọi thứ bằng thuộc tính [Nối tiếp]. Chỉ có một nhược điểm là một đối tượng phải được bọc trong lớp ẩn danh, do đó mảng byte thu được với tuần tự nhị phân có thể khác với đối tượng này.

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

Lớp ẩn danh được sử dụng vì BSON nên bắt đầu bằng một lớp hoặc mảng. Tôi đã không cố gắng khử tuần tự byte [] trở lại đối tượng và không chắc nó có hoạt động không, nhưng đã kiểm tra tốc độ chuyển đổi thành byte [] và nó hoàn toàn đáp ứng nhu cầu của tôi.

Làm thế nào về tuần tự hóa? hãy xem ở đây .