我正在编写一个UDP服务器,并希望减少每个传入和传出数据报数据包发生的分配数量。我想做的一件事是重用我分配的流来读取和写入数据报数据包。
我有这种方法,它在接收数据包时使用BinaryReader
实例将缓冲区读取到实例对象上。
// Simplified version of the receive data method.
private void ReceiveClientData(IAsyncResult result)
{
int receivedData = socket.EndReceiveFrom(result, ref endPoint);
if (receivedData == 0)
{
this.ListenForData(socket);
return;
}
// Read the header in from the buffer first so we know what kind of message and how to route.
this.binaryReader.BaseStream.SetLength(receivedData);
this.binaryReader.BaseStream.Seek (0, SeekOrigin.Begin);
// Can't reset the MemoryStream buffer to the new packet buffer.
// How does this get consumed by the stream without allocating a new MemoryStream(buffer)?
byte[] buffer = (byte[])result.AsyncState;
// Deserialize the bytes into the header and datagram.
IClientHeader header = new ClientHeader();
header.GetMessageFromBytes(this.binaryReader);
IClientDatagram datagram = this.datagramFactory.CreateDatagramFromClientHeader(header);
datagram.GetMessageFromBytes(this.binaryReader);
this.ListenForData(socket);
}
在提供 I Seek 返回到流的开头时,重复使用相同的BinaryReader
和基础MemoryStream
是否安全?在进行一些读取后,套接字似乎不会同时读取或写入数据包,这需要我每次调用使用Stream
来EndReceiveFrom
。听起来确实可以并发执行每个操作,例如读取 + 写入,但不能并发读取或并发写入。正因为如此,我认为我可以重复使用阅读器,但我不确定我是否可以。为此,我必须为MemoryStream
提供一个新的缓冲区来读取。您可以这样做还是需要为从套接字接收的每个新数据包创建一个新MemoryBuffer
?
我想采用相同的方法将数据包发送回客户端。为了做到这一点,我尝试将MemoryStream
的长度设置为 0 并寻找回到开头。这似乎不会清除缓冲区,如此处的另一个答案中所述。我仍然在下面的t
中看到旧的缓冲区数据。
public void SendMessage(IServerDatagram message)
{
this.binaryStream.Seek(0, SeekOrigin.Begin);
this.binaryStream.SetLength (0);
// Contains old buffer data.
var t = this.binaryStream.GetBuffer ();
message.Serialize (this.binaryWriter);
// Contains a mixture of new bytes + old bytes.
byte[] data = this.binaryStream.GetBuffer();
this.binaryWriter.Flush ();
// Send the datagram packet.
this.udpServerSocket.SendTo(data, this.connectedClients.FirstOrDefault().Key);
}
我事先不知道缓冲区需要多大,所以我无法SetLength
到新缓冲区的大小。有没有其他方法可以重复使用 Stream,而不必为每条消息实例一个新流?如果我每秒发送数千条消息,可能会导致一些内存压力,不是吗?
我在使用流、阅读器和网络内容时遇到了相关问题 - 并选择采取一种不同的方法。我研究了BinaryReader
、BinaryWriter
和BitConverter
实现,并编写了扩展方法,直接在底层 byte[] 缓冲区上读取和写入数据。温和的PITA,但我不再有流和读者或作家。
例如,这里有一个 int 写入扩展方法:
[System.Security.SecuritySafeCritical]
public unsafe static int Write( this byte[ ] array, int value, int offset = 0 )
{
if ( offset + sizeof( int ) > array.Length ) throw new IndexOutOfRangeException( );
fixed ( byte* b = array )
{
*( ( int* ) ( b + offset ) ) = value;
}
return sizeof( int );
}
返回可能看起来很愚蠢,但所有扩展方法都返回我"移动"到字节数组中的字节数......这样我就可以始终如一地知道我在哪里;伪流,如果你愿意的话。此外,编写代码并不总是知道它在写什么。每个简单类型都有相同的覆盖,一个用于字符串,一个用于 byte[]。
我更关心的是客户端,我的操作环境更加受限......并且我维护一个长期存在的读取缓冲区。UdpClient.Receive
方法每次读取都会生成新的字节数组,这简直要了我的命。GC疯了...当然,这对UDP流媒体非常具有破坏性:-)因此,我找到了Receive
和ReceiveAsync
实现,并发现我可以控制底层袜子需要喂食的内容,并再次制作了自己的RecieveBroadcastToBuffer
扩展方法:
const int MaxUdpSize = 0x0000ffff;
const int AnyPort = 0;
static EndPoint anyV4Endpoint = new IPEndPoint( IPAddress.Any, AnyPort );
static EndPoint anyV6Endpoint = new IPEndPoint( IPAddress.IPv6Any, AnyPort );
/// <summary>Receives a UDP datagram into the specified buffer at the specified offset</summary>
/// <returns>The length of the received data</returns>
public static int ReceiveBroadcastToBuffer( this UdpClient client, byte[ ] buffer, int offset = 0 )
{
int received;
var socket = client.Client;
if ( socket.AddressFamily == AddressFamily.InterNetwork )
{
received = socket.ReceiveFrom( buffer, offset, MaxUdpSize, SocketFlags.None, ref anyV4Endpoint );
}
else
{
received = socket.ReceiveFrom( buffer, offset, MaxUdpSize, SocketFlags.None, ref anyV6Endpoint );
}
return received;
}
这几乎正是UdpClient.Receive
所做的......除了我管理缓冲区。我发现UdpClient
使用单个缓冲区进行读取,而我只是在发送端使用普通的Socket
。