public static SocketAwaitable SendAsync(this Socket socket, SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.SendAsync(awaitable.EventArgs))
awaitable.WasCompleted = true;
return awaitable;
}
public static SocketAwaitable ReceiveAsync(this Socket socket, SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.ReceiveAsync(awaitable.m_eventArgs))
awaitable.m_wasCompleted = true;
return awaitable;
}
/// <summary>
/// Begins an asynchronous to disconnect from a remote host using await.
/// </summary>
/// <param name="socket">The connected <see cref="Socket"/> object to use.</param>
/// <param name="awaitable">The <see cref="SocketAwaitable"/> to await on.</param>
/// <returns>A <see cref="SocketAwaitable"/> object ready to be reused.</returns>
public static SocketAwaitable DisconnectAsync(this Socket socket, SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.DisconnectAsync(awaitable.EventArgs))
{
awaitable.IsCompleted = true;
}
return(awaitable);
}
public static SocketAwaitable SendToAsync(this Socket socket, SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.SendToAsync(awaitable.m_eventArgs))
{
awaitable.m_wasCompleted = true;
}
return awaitable;
}
/// <summary>
/// Begins an asynchronous to a connection to a remote host using await.
/// </summary>
/// <param name="socket">The connected <see cref="Socket"/> object to use.</param>
/// <param name="awaitable">The <see cref="SocketAwaitable"/> to await on.</param>
/// <returns>A <see cref="SocketAwaitable"/> object ready to be reused.</returns>
public static SocketAwaitable ConnectAsync(this Socket socket, SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.ConnectAsync(awaitable.EventArgs))
{
awaitable.IsCompleted = true;
}
return awaitable;
}
/// <summary>
/// Begins an asynchronous to disconnect from a remote host using await.
/// </summary>
/// <param name="socket">The connected <see cref="Socket"/> object to use.</param>
/// <param name="awaitable">The <see cref="SocketAwaitable"/> to await on.</param>
/// <returns>A <see cref="SocketAwaitable"/> object ready to be reused.</returns>
public static SocketAwaitable DisconnectAsync(this Socket socket, SocketAwaitable awaitable)
{
awaitable.Reset();
socket.Dispose();
awaitable.IsCompleted = true;
return(awaitable);
}
/// <summary>
/// Begins an asynchronous to accept an incoming connection attempt using await.
/// </summary>
/// <param name="socket">The connected <see cref="Socket"/> object to use.</param>
/// <param name="awaitable">The <see cref="SocketAwaitable"/> to await on.</param>
/// <returns>A <see cref="SocketAwaitable"/> object ready to be reused.</returns>
public static SocketAwaitable AcceptAsync(this Socket socket, SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.AcceptAsync(awaitable.EventArgs))
{
awaitable.IsCompleted = true;
}
return awaitable;
}
private static SocketAwaitable ReceiveAsync(this Socket socket,
SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.ReceiveAsync(awaitable.EventArgs))
{
awaitable.IsCompleted = true;
}
return(awaitable);
}
/// <summary>
/// Creates a proper awaitable async receive object.
/// </summary>
/// <param name="socket"></param>
/// <param name="awaitable"></param>
/// <returns></returns>
internal static SocketAwaitable ReceiveAsync(this Socket socket,
SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.ReceiveAsync(awaitable.pEventArgs))
awaitable.pWasCompleted = true;
return awaitable;
}
public static SocketAwaitable ReceiveAsync(this Socket socket,
SocketAwaitable awaitable)
{
awaitable.Reset();
if (!socket.ReceiveAsync(awaitable.m_eventArgs))
{
awaitable.m_wasCompleted = true;
}
return(awaitable);
}
/// <summary>
/// Begins an asynchronous request to receive data from a connected <see cref="Socket"/> object using await.
/// </summary>
/// <param name="awaitable">The <see cref="SocketAwaitable"/> to await on.</param>
/// <returns>A <see cref="SocketAwaitable"/> object ready to be reused.</returns>
public static SocketAwaitable ReceiveAsync(this SocketAwaitable awaitable)
{
awaitable.Reset();
var socket = awaitable.EventArgs.AcceptSocket;
if (!socket.ReceiveAsync(awaitable.EventArgs))
{
awaitable.IsCompleted = true;
}
return awaitable;
}
public async Task Send(byte[] buffer, int offset, int length)
{
_eventArgs.SetBuffer(buffer, offset, length);
var isPending = _socket.SendAsync(_eventArgs);
if (isPending)
{
_socketAwaitable.Reset();
await _socketAwaitable;
}
}
public static async Task SendAsync(this Socket socket, SocketAwaitable awaitable)
{
var isPending = socket.SendAsync(awaitable._eventArgs);
if (!isPending)
{
return;
}
awaitable.Reset();
await awaitable;
}
public async Task <int> ReceiveAsync(byte[] buffer, int offset, int maxCountToReceive)
{
_readArgs.SetBuffer(buffer, offset, maxCountToReceive);
var isPending = _socket.ReceiveAsync(_readArgs);
if (isPending)
{
_readAwaitable.Reset();
await _readAwaitable;
}
return(_readArgs.BytesTransferred);
}
public async Task EnsureEnoughData(int amountOfBytesToGuarantee)
{
if (BytesLeftInBuffer >= amountOfBytesToGuarantee)
{
return;
}
var bytesReceived = 0;
while (amountOfBytesToGuarantee > 0)
{
// Nearing the end of the buffer, we must move all remaining data to the beginning
// so that we can continue to receive.
if (Buffer.Length < Offset + BytesLeftInBuffer + amountOfBytesToGuarantee)
{
if (BytesUnallocatedInBuffer - BytesLeftInBuffer < amountOfBytesToGuarantee)
{
throw new InvalidOperationException("Our buffer is too small.");
}
System.Buffer.BlockCopy(Buffer, Offset, Buffer, 0, BytesLeftInBuffer);
Offset = 0;
}
_readArgs.SetBuffer(Buffer, WriteOffset, BytesUnallocatedInBuffer);
var isPending = _socket.ReceiveAsync(_readArgs);
if (isPending)
{
_readAwaitable.Reset();
await _readAwaitable;
}
if (_readArgs.BytesTransferred == 0)
{
throw new InvalidOperationException("We got disconnected. TODO: Change this exception.");
}
amountOfBytesToGuarantee -= _readArgs.BytesTransferred;
bytesReceived += _readArgs.BytesTransferred;
}
WriteOffset += bytesReceived;
}
protected async Task Connect()
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_writeArgs.RemoteEndPoint = new DnsEndPoint(_remoteHost, _remotePort);
var isPending = _socket.ConnectAsync(_writeArgs);
if (isPending)
{
_writeAwaitable.Reset();
await _writeAwaitable;
}
_sender = new SocketSender(_socket, _writeArgs, _writeAwaitable);
_receiver = new SocketReceiver(_socket, _readArgs, _readAwaitable, _readBuffer);
await _encoder.EncodeHandshake(_sender, CurrentVersion);
#pragma warning disable 4014 //Need to run it in a separate task to not block the calling class.
Task.Run(ReceiveMessages);
#pragma warning restore 4014
}