public Task SendAsync(INetworkPacket package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (_serializer == null)
{
throw new NullReferenceException(nameof(_serializer));
}
if (_serialPort == null)
{
throw new NullReferenceException(nameof(_serialPort));
}
if (!_serialPort.IsOpen)
{
throw new Exception("Serial port is not open.");
}
using (var stream = new MemoryStream())
{
var length = _serializer.Serialize(package, stream);
_serialPort.Write(stream.ToArray(), 0, length);
return(Task.CompletedTask);
}
}
public void MessageIsSerializedBeforeSend()
{
_serializer.Serialize(20).Returns("2000");
_sender.Send(20);
_protocol.Received().SendPacket("2000");
}
private void SendPacket(Packet packet)
{
var msg = _client.CreateMessage();
var workStream = new MemoryStream();
_packetSerializer.Serialize(workStream, packet);
msg.Write(workStream.GetBuffer(), 0, (int)workStream.Length);
_client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered, 0);
}
public async Task <bool> Write(IPacket packet)
{
if (!_client?.Connected ?? false)
{
return(false);
}
var serialized = packetSerializer.Serialize(packet);
bool worked = false;
foreach (var data in serialized)
{
worked = await _client.WriteData(data);
}
if (worked)
{
((BroadcastUtility)On).BroadcastPacketSent(packet);
}
return(worked);
}
private void ProcessSend()
{
lock (_sendPacketQueue)
{
while (_sendPacketQueue.Count > 0)
{
// 큐에서 보낼 패킷을 얻어 바이트 스트림 구성
object packet;
{
packet = _sendPacketQueue[0];
_sendPacketQueue.RemoveAt(0);
}
if (packet == null)
{
_client.Client.Shutdown(SocketShutdown.Send);
break;
}
int length;
using (var ms = new MemoryStream())
{
_packetSerializer.Serialize(ms, packet);
length = (int)ms.Length;
if (length > _sendBuf.Length)
{
_logger?.ErrorFormat("ProcessSend got too large packet. Length={0}", length);
Close();
return;
}
Array.Copy(ms.GetBuffer(), _sendBuf, length);
}
// 전송
try
{
_sendProcessing = true;
_client.GetStream().BeginWrite(_sendBuf, 0, length, ProcessSendCallback, null);
break;
}
catch (Exception e)
{
_logger?.Trace("ProcessSend Exception", e);
break;
}
}
}
}
public void Serialize(TestMessage testMessage, BinaryWriter writer)
{
writer.Write(BitConverter.GetBytes(TestMessage.Header));
writer.Write(BitConverter.GetBytes(testMessage.Int32Field));
writer.Write(BitConverter.GetBytes(testMessage.Float32Field));
writer.Write(BitConverter.GetBytes(testMessage.Int16Field));
writer.Write(BitConverter.GetBytes(testMessage.Int8Field));
var VarcharFieldBytes = Encoding.ASCII.GetBytes(testMessage.VarcharField);
writer.Write((byte)VarcharFieldBytes.Length);
writer.Write(VarcharFieldBytes);
writer.Write(Encoding.ASCII.GetBytes(testMessage.CharField));
writer.Write(BitConverter.GetBytes(testMessage.Uint32Field));
writer.Write(BitConverter.GetBytes(testMessage.Uint16Field));
writer.Write(BitConverter.GetBytes(testMessage.Uint8Field));
_customTypeDtoSerializer.Serialize(testMessage.CustomTypeField, writer);
foreach (var element in testMessage.ArrayField)
{
_stringsObjectDtoSerializer.Serialize(element, writer);
}
foreach (var element in testMessage.PrimitiveNumericArrayField)
{
writer.Write(BitConverter.GetBytes(element));
}
foreach (var element in testMessage.PrimitiveCharArrayField)
{
writer.Write(Encoding.ASCII.GetBytes(element));
}
foreach (var element in testMessage.PrimitiveVarcharArrayField)
{
var elementBytes = Encoding.ASCII.GetBytes(element);
writer.Write((byte)elementBytes.Length);
writer.Write(elementBytes);
}
foreach (var element in testMessage.PrimitiveSingleByteArrayField)
{
writer.Write(BitConverter.GetBytes(element));
}
}
public void Send(INetworkPacket package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (_serializer == null)
{
throw new NullReferenceException(nameof(_serializer));
}
var broadcastDomain = new IPEndPoint(IPAddress.Broadcast, _port);
using (var stream = new MemoryStream())
{
var length = _serializer.Serialize(package, stream);
foreach (var nic in NetworkInterface.GetAllNetworkInterfaces())
{
switch (nic.NetworkInterfaceType)
{
case NetworkInterfaceType.Wireless80211:
case NetworkInterfaceType.Ethernet:
{
if (nic.Supports(NetworkInterfaceComponent.IPv4) == false)
{
continue;
}
var adapterProperties = nic.GetIPProperties();
foreach (var ua in adapterProperties.UnicastAddresses.Where(x => x.Address.AddressFamily == AddressFamily.InterNetwork))
{
try
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
socket.ReceiveTimeout = 200;
socket.Bind(new IPEndPoint(ua.Address, _port));
var result = socket.SendTo(stream.ToArray(), broadcastDomain);
int BUFFER_SIZE_ANSWER = 1024;
byte[] bufferAnswer = new byte[BUFFER_SIZE_ANSWER];
do
{
try
{
socket.Receive(bufferAnswer);
var returnData = Encoding.ASCII.GetString(bufferAnswer, 0, bufferAnswer.Length);
if (true)
{
}
//DevicesList.Add(GetMyDevice(bufferAnswer)); //Corresponding functions to get the devices information. Depends on the application.
}
catch { break; }
} while (socket.ReceiveTimeout != 0); //fixed receive timeout for each adapter that supports our broadcast
socket.Close();
}
catch { }
}
}
break;
}
}
}
}
public virtual void Send(T message)
{
_protocol.SendPacket(_serializer.Serialize(message));
}
protected void SendingTask(CancellationToken cancellationToken)
{
DateTime startTime;
while (!_outgoingMsgQueue.IsEmpty || !_sentUnacknowledgedMessages.IsEmpty || !_pendingACKMessages.IsEmpty || !cancellationToken.IsCancellationRequested)
{
// Store start date time of receiving task to calculate an accurate sending delay.
startTime = DateTime.Now;
//Send Messages...
if (_socket != null && !_outgoingMsgQueue.IsEmpty)
{
while (_outgoingMsgQueue.TryDequeue(out RNetMessage netMsg))
{
byte[] data;
try
{
data = _serializer.Serialize(netMsg);
}
catch (Exception ex)
{
_logger?.WriteError(new LogInfo("error while serializing netmessage: " + ex.Message));
continue;
}
int numOfSentBytes;
try
{
numOfSentBytes = _socket.SendTo(data, 0, data.Length, SocketFlags.None, netMsg.RemoteEndPoint);
}
catch (Exception ex)
{
_logger?.WriteError(new LogInfo("error while sending data: " + ex.Message));
continue;
}
if (numOfSentBytes == 0)
{
_logger?.WriteWarning(new LogInfo("Sent empty message. TransactionId: " + netMsg.TransactionId?.ToString()));
}
else
{
//Update statistics...
UpdateSendStatistics(numOfSentBytes);
//Start receiving...
StartReceiverTask();
}
if (netMsg.QoSType == RQoSType.Realiable || netMsg.QoSType == RQoSType.Internal)
{
_sentUnacknowledgedMessages.TryAdd(netMsg.TransactionId !.Value, new SentUnacknowledgedMessage(data, netMsg.RemoteEndPoint, DateTime.Now.AddMilliseconds(_settings.SendRetryDelay), netMsg.TransactionId.Value));
}
}
}
//resend unacknowledged Messages
if (_socket != null && !_sentUnacknowledgedMessages.IsEmpty && !cancellationToken.IsCancellationRequested)
{
foreach (var unAckMsg in _sentUnacknowledgedMessages)
{
if (unAckMsg.Value.NextRetryTime < DateTime.Now)
{
int numOfSentBytes = _socket.SendTo(unAckMsg.Value.SentData, 0, unAckMsg.Value.SentData.Length, SocketFlags.None, unAckMsg.Value.RemoteEndPoint);
if (numOfSentBytes != unAckMsg.Value.SentData.Length)
{
// Number of sent bytes unequal to message size.
var errorMsg = "Number of sent bytes unequal to message size. RemoteEndPoint: " + unAckMsg.Value.RemoteEndPoint;
_logger?.WriteError(new LogInfo(errorMsg));
Error?.Invoke(unAckMsg.Value.TransactionId);
}
else if (numOfSentBytes > 0)
{
//Start receiving...
StartReceiverTask();
}
UpdateSendStatistics(numOfSentBytes);
if (++unAckMsg.Value.RetriedTimes > _settings.NumberOfSendRetries)
{
_sentUnacknowledgedMessages.TryRemove(unAckMsg.Key, out _);
var errorMsg = "Number of max retries reached. RemoteEndPoint: " + unAckMsg.Value.RemoteEndPoint;
TotalPacketsLost++;
_logger?.WriteInfo(new LogInfo(errorMsg));
Error?.Invoke(unAckMsg.Value.TransactionId);
continue;
}
unAckMsg.Value.NextRetryTime = DateTime.Now.AddMilliseconds(_settings.SendRetryDelay);
}
}
}
//Send ACK Messages
if (_socket != null && !_pendingACKMessages.IsEmpty)
{
while (_pendingACKMessages.TryDequeue(out RReliableNetMessageACK ackMsg))
{
byte[] data;
try
{
data = _serializer.SerializeACKMessage(ackMsg);
}
catch (Exception ex)
{
_logger?.WriteError(new LogInfo("error while serializing ack message: " + ex.Message));
continue;
}
int numOfSentBytes = _socket.SendTo(data, 0, data.Length, SocketFlags.None, ackMsg.RemoteEndPoint);
if (numOfSentBytes == 0)
{
_logger?.WriteWarning(new LogInfo("Sent empty ack message. TransactionId: " + ackMsg.TransactionId.ToString()));
}
else
{
//Update statistics...
UpdateSendStatistics(numOfSentBytes);
}
}
}
// Nothing to do, take a short break. Delay = SendTickrateInMs - (Now - StartTime)
var delay = _settings.SendTickrateIsMs - (DateTime.Now.Subtract(startTime).TotalMilliseconds);
if (!cancellationToken.IsCancellationRequested && delay > 0)
{
Thread.Sleep((int)delay);
}
}
}