private void StartListeningAsync()
{
Connected?.Invoke(serverIPEndPoint);
while (true)
{
try{
int dataSize = TCPSegmentSizeFormater.ReceiveTCPSegmentSize(serverSocket).GetAwaiter().GetResult();
byte[] data = new byte[dataSize];
ArraySegment <byte> dataSegment = new ArraySegment <byte>(data);
int recievedData = 0;
while (recievedData < dataSize)
{
int lost = dataSize - recievedData;
if (lost > RecieveBufferLength)
{
lost = RecieveBufferLength;
}
ArraySegment <byte> tempSegment = dataSegment.SliceEx(recievedData, lost);
recievedData += serverSocket.ReceiveAsync(tempSegment, SocketFlags.None).GetAwaiter().GetResult();
}
RecieveDataEvent?.Invoke(dataSegment.Array, serverIPEndPoint);
}catch (ObjectDisposedException) {
return;
}catch (SocketException) {
ConnectionShutdown?.Invoke(serverIPEndPoint);
if (!AutoReconnect)
{
Reconnect().Wait();
}
}
}
}
private async void StartReceivingAsync(Socket clientSocket)
{
IPEndPoint iPEndPoint = clientSocket.RemoteEndPoint as IPEndPoint;
while (true)
{
try
{
int dataSize = await TCPSegmentSizeFormater.ReceiveTCPSegmentSize(clientSocket);
byte[] data = new byte[dataSize];
ArraySegment <byte> dataSegment = new ArraySegment <byte>(data);
int recieveSize = 0;
while (recieveSize < dataSize)
{
int bufferSize = dataSize - recieveSize;
if (bufferSize > RecieveBufferLength)
{
bufferSize = RecieveBufferLength;
}
ArraySegment <byte> partData = dataSegment.SliceEx(recieveSize, bufferSize);
recieveSize += await clientSocket.ReceiveAsync(partData, SocketFlags.None).ConfigureAwait(false);
}
if (recieveSize < 1)
{
throw new TCPProtocolException("Receive transfer data was damaged.");
}
RecieveDataEvent?.Invoke(dataSegment.Array, iPEndPoint);
}
catch (SocketException)
{
bool success = DisconnectClient(iPEndPoint);
if (success)
{
return;
}
}
catch (TransferException)
{
bool success = DisconnectClient(iPEndPoint);
if (success)
{
return;
}
}
}
}
public async Task SendDataAsync(byte[] data, IPEndPoint recipient)
{
Socket recipientSocket;
if (!clients.TryGetValue(recipient, out recipientSocket) || data == null)
{
throw new TCPProtocolException("Bad sending value.");
}
try
{
await TCPSegmentSizeFormater.SendTCPSegmentSize(recipientSocket, data.Length).ConfigureAwait(false);
ArraySegment <byte> dataSegment = new ArraySegment <byte>(data);
int sendData = 0;
while (sendData < data.Length)
{
int bufferSize = data.Length - sendData;
if (bufferSize > SendBufferLength)
{
bufferSize = SendBufferLength;
}
ArraySegment <byte> sliceData = dataSegment.SliceEx(sendData, bufferSize);
sendData += await recipientSocket.SendAsync(sliceData, SocketFlags.None).ConfigureAwait(false);
}
if (sendData < 1)
{
throw new TCPProtocolException("Message format error.");
}
}
catch (SocketException exce)
{
throw new TCPProtocolException("Connection shutdown.", exce);
}
catch (TransferException excep)
{
throw new TCPProtocolException("Undefined protocol.", excep);
}
}
public async Task SendDataAsync(byte[] data)
{
if (isConnected == false)
{
throw new TCPProtocolException("Dont Connected to server.");
}
if (data == null)
{
throw new TCPProtocolException("Bad sending value");
}
try{
ArraySegment <byte> dataSegment = new ArraySegment <byte>(data);
await TCPSegmentSizeFormater.SendTCPSegmentSize(serverSocket, data.Length);
int send = 0;
while (send < data.Length)
{
int lost = data.Length - send;
if (lost > SendBufferLength)
{
lost = SendBufferLength;
}
ArraySegment <byte> tempBuffer = dataSegment.SliceEx(send, lost);
send += await serverSocket.SendAsync(tempBuffer, SocketFlags.None);
}
if (send < 1)
{
throw new TCPProtocolException("${send} bytes send.Connection shutdown");
}
}catch (SocketException exc) {
throw new TCPProtocolException("Connection error.", exc);
}
catch (TransferException excep) {
throw new TCPProtocolException("Trasfer error.", excep);
}
}
