C# 在C语言中将消息分块成更小的块
我有一个C类来创建消息C# 在C语言中将消息分块成更小的块,c#,messages,C#,Messages,我有一个C类来创建消息 public class ExMessage { private UInt16 m_SendingId = 123; private byte m_control_byte_1; private enum destination_service : byte { serv_1 = 0x0, serv_2 = 0x1 };
public class ExMessage
{
private UInt16 m_SendingId = 123;
private byte m_control_byte_1;
private enum destination_service : byte
{
serv_1 = 0x0,
serv_2 = 0x1
};
private byte m_pd;
private byte m_filler_bytes;
private byte[] m_payload;
public byte[] Payload
{
get
{
return m_payload;
}
}
/// <summary>
/// Constructor.
/// </summary>
public ExMessage(byte[] payload)
{
m_pd = 0x0;
m_control_byte_1 = 0xA5;
m_payload = payload;
m_filler_bytes = 0xF;
}
protected void WriteBody(Stream stream)
{
stream.WriteByte(m_control_byte_1);
stream.WriteByte(0x0);
stream.WriteWordLittleEndian(m_SendingId);
stream.WriteByte((byte)destination_service.serv_2);
stream.WriteByte((byte)m_pd); // payload details
stream.WriteByte((byte)m_payload.Length); //write the payload length
var count = 0;
while (count < m_payload.Length) //copy over the actual payload.
{
stream.WriteByte((byte)m_payload[count]);
count++;
}
var len = 48 - (5 + m_payload.Length);
count = 0;
while (count < len) //copy over spare bytes 0x3
{
stream.WriteByte(m_filler_bytes);
count++;
}
}
public byte[] ToBytes()
{
MemoryStream stream = new MemoryStream();
WriteBody(stream);
return stream.ToArray();
}
3如果没有，处理这种情况的最佳方法是什么
var size = 4;
var messages =
Encoding.UTF8.GetBytes("HelloWorld") //48 65 6C 6C 6F 57 6F 72 6C 64
.Select((b, i) => new { b, i }) // Enumerable of byte and index
.GroupBy(x => x.i / size, x => x.b) // group by index divide by block size
.Select(x => new ExMessage(x.ToArray())); // create messages
public class ExMessage
{
private const int __size = 4;
public static ExMessage[] Create(byte[] payload)
{
return payload
.Select((b, i) => new { b, i })
.GroupBy(x => x.i / __size, x => x.b)
.Select(x => new ExMessage(x.ToArray()))
.ToArray();
}
/* rest of class */
}
var messages = ExMessage.Create(Encoding.UTF8.GetBytes("HelloWorld"));
class ExMessage
{
...
public static List<ExMessage> CreateMessages(byte[] payload)
{
List<byte[]> chunks = ... split payload into 40byte chunks...
return chunks.Select(p => new ExMessage(p).ToList();
}
...
}
public class ExMessage
{
private const int __size = 4;
public static ExMessage[] Create(byte[] payload)
{
return payload
.Select((b, i) => new { b, i })
.GroupBy(x => x.i / __size, x => x.b)
.Select(x => new ExMessage(x.ToArray()))
.ToArray();
}
/* rest of class */
}
var messages = ExMessage.Create(Encoding.UTF8.GetBytes("HelloWorld"));
class ExMessage
{
...
public static List<ExMessage> CreateMessages(byte[] payload)
{
List<byte[]> chunks = ... split payload into 40byte chunks...
return chunks.Select(p => new ExMessage(p).ToList();
}
...
}
我会这样做：
var size = 4;
var messages =
Encoding.UTF8.GetBytes("HelloWorld") //48 65 6C 6C 6F 57 6F 72 6C 64
.Select((b, i) => new { b, i }) // Enumerable of byte and index
.GroupBy(x => x.i / size, x => x.b) // group by index divide by block size
.Select(x => new ExMessage(x.ToArray())); // create messages
public class ExMessage
{
private const int __size = 4;
public static ExMessage[] Create(byte[] payload)
{
return payload
.Select((b, i) => new { b, i })
.GroupBy(x => x.i / __size, x => x.b)
.Select(x => new ExMessage(x.ToArray()))
.ToArray();
}
/* rest of class */
}
var messages = ExMessage.Create(Encoding.UTF8.GetBytes("HelloWorld"));
class ExMessage
{
...
public static List<ExMessage> CreateMessages(byte[] payload)
{
List<byte[]> chunks = ... split payload into 40byte chunks...
return chunks.Select(p => new ExMessage(p).ToList();
}
...
}
public class ExMessage
{
private const int __size = 4;
public static ExMessage[] Create(byte[] payload)
{
return payload
.Select((b, i) => new { b, i })
.GroupBy(x => x.i / __size, x => x.b)
.Select(x => new ExMessage(x.ToArray()))
.ToArray();
}
/* rest of class */
}
var messages = ExMessage.Create(Encoding.UTF8.GetBytes("HelloWorld"));
class ExMessage
{
...
public static List<ExMessage> CreateMessages(byte[] payload)
{
List<byte[]> chunks = ... split payload into 40byte chunks...
return chunks.Select(p => new ExMessage(p).ToList();
}
...
}
public class ExMessage
{
private const int __size = 4;
public static ExMessage[] Create(byte[] payload)
{
return payload
.Select((b, i) => new { b, i })
.GroupBy(x => x.i / __size, x => x.b)
.Select(x => new ExMessage(x.ToArray()))
.ToArray();
}
/* rest of class */
}
var messages = ExMessage.Create(Encoding.UTF8.GetBytes("HelloWorld"));
class ExMessage
{
...
public static List<ExMessage> CreateMessages(byte[] payload)
{
List<byte[]> chunks = ... split payload into 40byte chunks...
return chunks.Select(p => new ExMessage(p).ToList();
}
...
}
public class ExMessage
{
private const int __size = 4;
public static ExMessage[] Create(byte[] payload)
{
return payload
.Select((b, i) => new { b, i })
.GroupBy(x => x.i / __size, x => x.b)
.Select(x => new ExMessage(x.ToArray()))
.ToArray();
}
/* rest of class */
}
var messages = ExMessage.Create(Encoding.UTF8.GetBytes("HelloWorld"));
class ExMessage
{
...
public static List<ExMessage> CreateMessages(byte[] payload)
{
List<byte[]> chunks = ... split payload into 40byte chunks...
return chunks.Select(p => new ExMessage(p).ToList();
}
...
}
一些与问题无关的评论：-如果您事先不知道内存流的大小，那么以增量方式写入内存流是低效的。这是因为调整了内部缓冲区的大小。看来你会知道的。有鉴于此，预先调整流的大小，以确保流足够长，可以容纳整个块，即使您以增量方式写入流。-注意不要让单个内存流变得太大。查看.net中大型对象上的文档-不要增量地从m_有效负载写入，而是使用一个写调用一次写入整个数据块和一些注释，这多少与问题无关：-如果事先不知道内存流的大小，则增量写入内存流是低效的。这是因为调整了内部缓冲区的大小。看来你会知道的。有鉴于此，预先调整流的大小，以确保流足够长，可以容纳整个块，即使您以增量方式写入流。-注意不要让单个内存流变得太大。在.net中查看大型对象上的文档-不要增量地从m_有效负载写入，而是使用单个写调用一次性写入整个块上面的解决方案需要什么包。它需要C反应式扩展吗？如果是这样的话，我宁愿避免它。@liv2hak-不，这只是标准的LINQ。我不太明白其中的逻辑。请再给我解释一下，我需要把区块号传给我的构造函数ExMessage@liv2hak-您在ExMessage的构造函数中没有区块号，但如果需要添加它，则它将如下所示：.Selectx=>new ExMessagex.Key，x.ToArray。上述解决方案需要什么包。它需要C反应式扩展吗？如果是这样的话，我宁愿避免它。@liv2hak-不，这只是标准的LINQ。我不太明白其中的逻辑。请再给我解释一下，我需要把区块号传给我的构造函数ExMessage@liv2hak-您在ExMessage的构造函数中没有区块编号，但如果需要添加它，则它将如下所示：.Selectx=>new ExMessagex.Key，x.ToArray。