public override void Send(byte[] buffer, int index, int length, INode destination)
{
var clientSocket = SocketMap[destination];
try
{
if (clientSocket.WasDisposed)
{
CloseConnection(clientSocket);
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
List <IByteBuf> encodedMessages;
Encoder.Encode(ConnectionAdapter, buf, out encodedMessages);
foreach (var message in encodedMessages)
{
var state = CreateNetworkState(clientSocket.Socket, destination, message, 0);
clientSocket.Socket.BeginSendTo(message.ToArray(), 0, message.ReadableBytes, SocketFlags.None,
destination.ToEndPoint(),
SendCallback, state);
}
}
catch (SocketException ex)
{
CloseConnection(ex, clientSocket);
}
catch (Exception ex)
{
OnErrorIfNotNull(ex, clientSocket);
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="buffer"></param>
/// <param name="index"></param>
/// <param name="length"></param>
/// <param name="destination"></param>
public override void Send(byte[] buffer, int index, int length, INode destination)
{
var clientSocket = SocketMap[destination.nodeConfig.ToString()];
try
{
if (clientSocket.WasDisposed)
{
CloseConnection(clientSocket);
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
List <IByteBuf> encodedMessages;
Encoder.Encode(ConnectionAdapter, buf, out encodedMessages);
foreach (var message in encodedMessages)
{
ListenerSocket.Write(message.ToArray(), message.ReaderIndex, message.ReadableBytes);
string log = String.Format("{0}:串口发送数据-->>{1}", DateTime.Now.ToString("hh:mm:ss"), this.Encoder.ByteEncode(message.ToArray()));
Console.WriteLine(log);
clientSocket.Receiving = true;
}
}
catch (Exception ex)
{
CloseConnection(ex, clientSocket);
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="buffer"></param>
/// <param name="index"></param>
/// <param name="length"></param>
/// <param name="destination"></param>
public override void Send(byte[] buffer, int index, int length, INode destination)
{
var clientSocket = SocketMap[destination.nodeConfig.ToString()];
try
{
if (clientSocket.WasDisposed)
{
CloseConnection(clientSocket);
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
Encoder.Encode(ConnectionAdapter, buf, out List <IByteBuf> encodedMessages);
foreach (var message in encodedMessages)
{
var state = CreateNetworkState(clientSocket.Local, destination, message, 0);
ListenerSocket.BeginSendTo(message.ToArray(), 0, message.ReadableBytes, SocketFlags.None,
destination.ToEndPoint <EndPoint>(), SendCallback, state);
LogAgent.Info(String.Format("发送数据-{0}-->>{1}", this.Listener.reactorType, this.Encoder.ByteEncode(message.ToArray())));
clientSocket.Receiving = true;
}
}
catch (Exception ex)
{
LogAgent.Error(ex.ToString());
CloseConnection(ex, clientSocket);
}
}
protected override void SendInternal(byte[] buffer, int index, int length, INode destination)
{
try
{
if (WasDisposed || !_client.Connected)
{
Close();
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
List <IByteBuf> encodedMessages;
Encoder.Encode(this, buf, out encodedMessages);
foreach (var message in encodedMessages)
{
var bytesToSend = message.ToArray();
var bytesSent = 0;
while (bytesSent < bytesToSend.Length)
{
bytesSent += _client.Client.Send(bytesToSend, bytesSent, bytesToSend.Length - bytesSent,
SocketFlags.None);
}
}
}
catch (SocketException ex)
{
Close(ex);
}
catch (Exception ex)
{
InvokeErrorIfNotNull(ex);
}
}
public override void Send(byte[] buffer, int index, int length, INode destination)
{
if (!SocketMap.TryGetValue(destination, out var clientSocket))
{
return;
}
try
{
if (clientSocket.WasDisposed || !clientSocket.Socket.Connected)
{
CloseConnection(clientSocket);
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
List <IByteBuf> encodedMessages;
clientSocket.Encoder.Encode(ConnectionAdapter, buf, out encodedMessages);
foreach (var message in encodedMessages)
{
var bytesToSend = message.ToArray();
var bytesSent = 0;
while (bytesSent < bytesToSend.Length)
{
bytesSent += clientSocket.Socket.Send(bytesToSend, bytesSent, bytesToSend.Length - bytesSent,
SocketFlags.None);
}
HeliosTrace.Instance.TcpInboundClientSend(bytesSent);
HeliosTrace.Instance.TcpInboundSendSuccess();
}
}
catch (SocketException ex)
{
HeliosTrace.Instance.TcpClientSendFailure();
CloseConnection(ex, clientSocket);
}
catch (Exception ex)
{
HeliosTrace.Instance.TcpClientSendFailure();
OnErrorIfNotNull(ex, clientSocket);
}
}
protected override void SendInternal(byte[] buffer, int index, int length, INode destination)
{
try
{
if (Client == null || WasDisposed)
{
HeliosTrace.Instance.UdpClientSendFailure();
Close();
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
List <IByteBuf> encodedMessages;
Encoder.Encode(this, buf, out encodedMessages);
foreach (var message in encodedMessages)
{
var bytesToSend = message.ToArray();
var bytesSent = 0;
while (bytesSent < bytesToSend.Length)
{
bytesSent += Client.SendTo(bytesToSend, bytesSent, bytesToSend.Length - bytesSent,
SocketFlags.None, destination.ToEndPoint());
}
HeliosTrace.Instance.UdpClientSend(bytesSent);
HeliosTrace.Instance.UdpClientSendSuccess();
}
}
catch (SocketException ex)
{
HeliosTrace.Instance.UdpClientSendFailure();
Close(ex);
}
catch (Exception ex)
{
HeliosTrace.Instance.UdpClientSendFailure();
InvokeErrorIfNotNull(ex);
}
}
private void SendInternal(byte[] buffer, int index, int length, INode remoteHost)
{
try
{
if (WasDisposed || Socket == null || !Socket.Connected)
{
Close();
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
List <IByteBuf> encodedMessages;
Encoder.Encode(this, buf, out encodedMessages);
foreach (var message in encodedMessages)
{
var bytesToSend = message.ToArray();
var bytesSent = 0;
while (bytesSent < bytesToSend.Length)
{
bytesSent += Socket.Send(bytesToSend, bytesSent, bytesToSend.Length - bytesSent,
SocketFlags.None);
}
HeliosTrace.Instance.TcpInboundClientSend(bytesSent);
HeliosTrace.Instance.TcpInboundSendSuccess();
}
}
catch (SocketException ex)
{
HeliosTrace.Instance.TcpClientSendFailure();
Close();
}
catch (Exception ex)
{
HeliosTrace.Instance.TcpClientSendFailure();
InvokeErrorIfNotNull(ex);
}
}
protected NetworkState CreateNetworkState(Socket socket, INode remotehost)
{
return(CreateNetworkState(socket, remotehost, Allocator.Buffer(), BufferSize));
}
protected NetworkState CreateNetworkState(SerialPort socket, INode remotehost)
{
IByteBuf byteBuf = Allocator == null ? null : Allocator.Buffer();
return(CreateNetworkState(socket, remotehost, byteBuf, BufferSize));
}
public IByteBuf ReadBytes(IByteBuf destination)
{
return(Allocator.Buffer());
}
