我正在写一个原型 TCP 连接，我在均匀化要发送的数据时遇到了一些问题。
目前，我只发送字符串，但将来我们希望能够发送任何对象。
目前的代码很简单，因为我认为一切都可以转换成字节数组：
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[]'.
...
}
这当然很容易用
解决if( state.headerObject is System.String ){...}
问题是，如果我那样做，我需要检查在运行时不能转换为 byte[] 的每种类型的对象。
因为我不知道每个对象都不能在运行时转换为 byte[]，所以这真的不是一个选项。
如何将任何对象转换为 C# .NET 4.0 中的字节数组？
BinaryFormatterbyte[] ObjectToByteArray(object obj)
{
if(obj == null)
return null;
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
bf.Serialize(ms, obj);
return ms.ToArray();
}
}
请注意，
objobjSerializable查看这篇文章：http://www.morgantechspace.com/2013/08/convert-object-to-byte-array-and-vice.html
使用以下代码
// 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;
}
正如其他人之前所说，您可以使用二进制序列化，但它可能会产生额外的字节或被反序列化为具有不完全相同数据的对象。另一方面，使用反射非常复杂且非常慢。 还有另一种解决方案可以将您的对象严格转换为字节，反之亦然 - 编组：
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);
并将字节转换为对象：
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);
与您自己的逐字段序列化相比，将这种方法用于小对象和结构明显较慢且部分不安全（因为从/到非托管内存进行双重复制），但这是将对象严格转换为 byte[] 而无需实现的最简单方法序列化且没有 [Serializable] 属性。
使用
Encoding.UTF8.GetBytesMemoryStreambyte[] SerializeObject(object value) =>Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(value));
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 |
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;
}
}
您可以像下面的代码一样使用它。
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>();
扩展类中的组合解决方案：
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);
}
}
像这样简单的东西怎么样？
return ((object[])value).Cast<byte>().ToArray();
您可以使用框架中的内置序列化工具并序列化到MemoryStream。这可能是最直接的选择，但可能会产生比您的场景绝对必要的更大的 byte[]。
如果是这种情况，您可以利用反射来迭代要序列化的对象中的字段和/或属性，并手动将它们写入 MemoryStream，如果需要序列化非平凡类型，则递归调用序列化。此方法更复杂，需要更多时间来实现，但可以让您更好地控制序列化流。
我宁愿使用表达“序列化”而不是“转换成字节”。序列化一个对象意味着将它转换成一个字节数组（或 XML，或其他东西），可以在远程盒子上使用它来重新构造该对象。在 .NET 中，
Serializable一个额外的实现，它使用 Newtonsoft.Json 二进制 JSON，不需要用 [Serializable] 属性标记所有内容。只有一个缺点是一个对象必须被包裹在匿名类中，所以二进制序列化得到的字节数组可能与这个不同。
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();
}
}
}
使用匿名类是因为 BSON 应该以类或数组开头。 我没有尝试将 byte[] 反序列化回对象，不确定它是否有效，但测试了转换为 byte[] 的速度，它完全满足我的需求。
将对象转换为字节数组的替代方法：
TypeConverter objConverter = TypeDescriptor.GetConverter(objMsg.GetType());
byte[] data = (byte[])objConverter.ConvertTo(objMsg, typeof(byte[]));
using System.Text.Json;
public static class MessageEncoder
{
public static byte[] EncodeMessage<TObject>(this TObject message)
{
return JsonSerializer.SerializeToUtf8Bytes(message);
}
}