[英]Byte for byte serialization of a struct in C#
我正在寻找 C# 中序列化的语言支持。 我可以从 ISerializable 派生并通过在字节缓冲区中复制成员值来实现序列化。 但是,我更喜欢一种更自动化的方式,就像在 C/C++ 中可以做的那样。
考虑以下代码:
using System;
using System.Text;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
namespace XBeeHelper
{
class XBee
{
[Serializable()]
public struct Frame<FrameType> where FrameType : struct
{
public Byte StartDelimiter;
public UInt16 Lenght;
public Byte APIIdentifier;
public FrameType FrameData;
public Byte Checksum;
}
[Serializable()]
public struct ModemStatus
{
public Byte Status;
}
public Byte[] TestSerialization()
{
Frame<ModemStatus> frame = new Frame<ModemStatus>();
frame.StartDelimiter = 1;
frame.Lenght = 2;
frame.APIIdentifier = 3;
frame.FrameData.Status = 4;
frame.Checksum = 5;
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream();
formatter.Serialize(stream, frame);
Byte[] buffer = stream.ToArray();
return buffer;
}
}
}
我有一个通用的 Frame 结构,用作许多类型有效负载的包装器,用于串行传输。 ModemStatus 是此类有效负载的一个示例。
但是,运行 TestSerialization() 会返回一个382字节长的缓冲区(没有预期的内容)。 它应该包含 6 个字节? 是否可以在不手动序列化的情况下正确序列化这些数据?
只需使用这两种方法:
public static class StructTools
{
/// <summary>
/// converts byte[] to struct
/// </summary>
public static T RawDeserialize<T>(byte[] rawData, int position)
{
int rawsize = Marshal.SizeOf(typeof(T));
if (rawsize > rawData.Length - position)
throw new ArgumentException("Not enough data to fill struct. Array length from position: "+(rawData.Length-position) + ", Struct length: "+rawsize);
IntPtr buffer = Marshal.AllocHGlobal(rawsize);
Marshal.Copy(rawData, position, buffer, rawsize);
T retobj = (T)Marshal.PtrToStructure(buffer, typeof(T));
Marshal.FreeHGlobal(buffer);
return retobj;
}
/// <summary>
/// converts a struct to byte[]
/// </summary>
public static byte[] RawSerialize(object anything)
{
int rawSize = Marshal.SizeOf(anything);
IntPtr buffer = Marshal.AllocHGlobal(rawSize);
Marshal.StructureToPtr(anything, buffer, false);
byte[] rawDatas = new byte[rawSize];
Marshal.Copy(buffer, rawDatas, 0, rawSize);
Marshal.FreeHGlobal(buffer);
return rawDatas;
}
}
并像这样指定您的结构(指定确切的大小并按一个字节打包(对齐)。默认为 8):
[StructLayout(LayoutKind.Explicit, Size = 11, Pack = 1)]
private struct MyStructType
{
[FieldOffset(0)]
public UInt16 Type;
[FieldOffset(2)]
public Byte DeviceNumber;
[FieldOffset(3)]
public UInt32 TableVersion;
[FieldOffset(7)]
public UInt32 SerialNumber;
}
现在您可以使用反序列化
StructTools.RawDeserialize<MyStructType>(byteArray, 0); // 0 is offset in byte[]
并使用序列化
StructTools.RawSerialize(myStruct);
正如Chris 所说,您可以使用不安全的代码 - 在这种情况下,您最好确保明确指定布局。 在这一点上,你当然会降低 CLR 的优化能力——你最终会得到不对齐的访问、原子性的丢失等。这可能与你无关,但值得牢记。
就个人而言,我认为这是一种非常脆弱的序列化/反序列化方式。 如果有任何变化,您的数据将无法读取。 如果您尝试在使用不同字节序的架构上运行,您会发现所有值都搞砸了等等。此外,一旦您需要使用引用类型,使用内存布局就会失败——这很可能影响您自己的类型设计,鼓励您在原本会使用类的地方使用结构。
我更喜欢明确地读取和写入值(例如使用 BinaryWriter,或者最好是允许您设置字节序的二进制写入器版本)或使用可移植的序列化框架,如Protocol Buffers 。
请参阅此链接。 这使用 Marshal 机制来获取结构的实际数据并将它们复制到 Byte[]。 另外,如何将它们复制回来。 这些函数的好处是它们是通用的,因此它将适用于您的所有结构(除非它们具有可变大小的数据类型,如字符串)
http://dooba.net/2009/07/c-sharp-and-serializing-byte-arrays/
也许通用的序列化/反序列化方法:
public static string SerializeObject<T>(T obj)
{
string xmlString = null;
using(MemoryStream memoryStream = new MemoryStream())
{
using(XmlSerializer xs = new XmlSerializer(typeof(T)))
{
XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
xs.Serialize(xmlTextWriter, obj);
memoryStream = (MemoryStream)xmlTextWriter.BaseStream;
xmlString = UTF8ByteArrayToString(memoryStream.ToArray());
}
}
return xmlString;
}
public static T DeserializeObject<T>(string xml)
{
XmlSerializer xs = new XmlSerializer(typeof(T));
MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(xml));
XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
return (T)xs.Deserialize(memoryStream);
}
原来在这里找到。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.