public static Task<ArraySegment<byte>> ReadBuffer(this Socket socket, int bufferSize)
{
var completionSource = new TaskCompletionSource<ArraySegment<byte>>();
var buffer = new byte[bufferSize];
var start = 0;
AsyncCallback callback = null;
callback = ar =>
{
int read;
try
{
read = socket.EndReceive(ar);
start += read;
}
catch (Exception e)
{
completionSource.SetException(e);
return;
}
if (read == 0 || start == bufferSize)
{
completionSource.SetResult(new ArraySegment<byte>(buffer, 0, start));
return;
}
socket.BeginReceive(buffer, start, bufferSize - start, SocketFlags.None, callback, null);
};
socket.BeginReceive(buffer, start, bufferSize - start, SocketFlags.Partial, callback, null);
return completionSource.Task;
}
/// <summary>
/// Asynchronously receives data from a connected socket.
/// </summary>
/// <param name="socket">
/// The socket from which to read data.
/// </param>
/// <param name="buffer">
/// An array of type <see cref="byte"/> that is the storage location for
/// the received data.
/// </param>
/// <param name="offset">
/// The zero-based position in the <paramref name="buffer"/> parameter at which to
/// start storing data.
/// </param>
/// <param name="size">
/// The number of bytes to receive.
/// </param>
/// <param name="socketFlags">
/// A bitwise combination of the <see cref="SocketFlags"/> values.
/// </param>
/// <returns>
/// The number of bytes received.
/// </returns>
public static Task<int> ReceiveAsync(
this Socket socket,
byte[] buffer,
int offset,
int size,
SocketFlags socketFlags)
{
var tcs = new TaskCompletionSource<int>(socket);
socket.BeginReceive(
buffer,
offset,
size,
socketFlags,
iar =>
{
var t = (TaskCompletionSource<int>)iar.AsyncState;
var s = (Socket)t.Task.AsyncState;
try
{
t.TrySetResult(s.EndReceive(iar));
}
catch (Exception ex)
{
t.TrySetException(ex);
}
},
tcs);
return tcs.Task;
}
public static void AsyncReceive(this Socket socket, byte[] buffer, object state, Action<int, object> callback)
{
if (state == null)
throw new InvalidOperationException("State cannot be null");
socket.BeginReceive(buffer, 0, buffer.Length, 0, new AsyncCallback(ReceiveCallback), new State() { Socket = socket, Callback = new Callback(callback), UserDefinedState = state });
}
public static Task<int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags = SocketFlags.None)
{
if (buffer == null) throw new ArgumentNullException("buffer");
return Task<int>.Factory.FromAsync(
(ac, state) => socket.BeginReceive(buffer, offset, size, flags, ac, state),
socket.EndReceive,
null,
TaskCreationOptions.None);
}
public static Task<int> ReceiveAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
{
return Task<int>.Factory.FromAsync(
(callback, state) => socket.BeginReceive(
buffer.Array,
buffer.Offset,
buffer.Count,
socketFlags,
callback,
state),
socket.EndReceive, null);
}
public static Task<int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags, out SocketError error) {
var tsc = new TaskCompletionSource<int> ();
socket.BeginReceive (buffer, offset, size, flags, out error, asyncResult => {
try {
tsc.SetResult (socket.EndReceive (asyncResult));
} catch (Exception e) {
tsc.SetException (e);
}
}, null);
return tsc.Task;
}
public static Task<int> ReceiveAsync(this Socket socket,
byte[] buffer, int offset, int size, SocketFlags socketFlags)
{
if (socket == null) throw new ArgumentNullException(nameof(socket));
var tcs = new TaskCompletionSource<int>();
socket.BeginReceive(buffer, offset, size, socketFlags, ar =>
{
try { tcs.TrySetResult(socket.EndReceive(ar)); }
catch (Exception e) { tcs.TrySetException(e); }
}, state: null);
return tcs.Task;
}
public static async Task<UdpDatagram> ReceiveAsync(this UdpClient client)
{
byte[] bytes;
IPEndPoint ipEndPoint = null;
var task = Task.Factory
.FromAsync<byte[]>(
(callback, state) => client.BeginReceive(callback, state),
(IAsyncResult asyncResult) => client.EndReceive(asyncResult, ref ipEndPoint), null);
bytes = await task;
return new UdpDatagram(ipEndPoint, bytes);
}
public static void AsyncReceiveFixed(this Socket socket, byte[] buffer, int offset, int len, OnReceived receivedCallback, object state)
{
socket.BeginReceive(buffer, offset, len, SocketFlags.None, ar =>
{
var received = socket.EndReceive(ar);
if (received == 0)
receivedCallback.Invoke(state, null);
if (received < len)
AsyncReceiveFixed(socket, buffer, offset + received, len - received, receivedCallback, state);
else
receivedCallback.Invoke(state, buffer);
}, state);
}
internal static Task<int> ReceiveAsync(this Socket s, byte[] buffer, int offset, int count)
{
var tcs = new TaskCompletionSource<int>();
s.BeginReceive(buffer, offset, count, SocketFlags.None, iasr =>
{
try
{
tcs.SetResult(s.EndReceive(iasr));
}
catch (Exception e)
{
tcs.SetException(e);
}
}, null);
return tcs.Task;
}
public static Task<int> ReceiveAsync(this Socket socket,
byte[] buffer,
int offset = 0,
int size = 0,
SocketFlags socketFlags = SocketFlags.None) {
if(size <= 0)
size = buffer.Length;
var tcs = new TaskCompletionSource<int>();
socket.BeginReceive(buffer, offset, size, socketFlags,
iar => {
try {
tcs.TrySetResult(socket.EndReceive(iar));
}
catch(Exception ex) {
tcs.TrySetException(ex);
}
}, null);
return tcs.Task;
}
public static Task<byte[]> RecieveAsyncTask(this Socket socket, CancellationTokenSource cancellationTokenSource)
{
var buff = new List<ArraySegment<byte>>();
buff.Add(new ArraySegment<byte>(new byte[65535]));
return Task<byte[]>.Factory.FromAsync(
(ac, o) => socket.BeginReceive(buff, SocketFlags.None, ac, null),
ar =>
{
cancellationTokenSource.Token.ThrowIfCancellationRequested();
if (!socket.Connected)
{
throw new InvalidOperationException();
}
var length = socket.EndReceive(ar);
var result = new byte[length];
Array.Copy(buff[0].Array, result, length);
return result;
},
null);
}
public static Task<int> ReceiveAsync(this Socket socket, byte[] buffer,
int offset = 0, int size = -1,
SocketFlags flags =
SocketFlags.None)
{
if (size < 0)
size = buffer.Length;
var source = new TaskCompletionSource<int>(socket);
socket.BeginReceive(buffer, offset, size, flags, state =>
{
try
{
source.SetResult(socket.EndReceive(state));
}
catch (Exception e)
{
source.SetException(e);
}
}, source);
return source.Task;
}
public static void ReceiveAPM(this Socket socket, byte[] buffer, int offset, int count, SocketFlags flags, Action<int> handler)
{
var callback = new AsyncCallback(asyncResult => handler(((Socket)asyncResult.AsyncState).EndReceive(asyncResult)));
socket.BeginReceive(buffer, offset, count, flags, callback, socket);
}
internal static IObservable<int> ReceiveAsync(this Socket s, byte[] buffer, int offset, int count)
{
return new AsyncOperation<int>(
(c, st) => s.BeginReceive(buffer, offset, count, SocketFlags.None, c, st),
iasr => { return s.EndReceive(iasr); });
}
public static void ReceiveBytesAsync(this Socket socket, byte[] bytes, int offset, int count, Action<byte[]> callback)
{
if (!MiscHelpers.Try(() => socket.BeginReceive(bytes, offset, count, SocketFlags.None, result => socket.OnBytesReceived(result, bytes, offset, count, callback), null)))
{
callback(null);
}
}
/// <summary>
/// Asynchronously receives data from a connected socket.
/// </summary>
/// <param name="socket">
/// The socket from which to read data.
/// </param>
/// <param name="buffer">
/// An array of type <see cref="byte"/> that is the storage location for
/// the received data.
/// </param>
/// <param name="offset">
/// The zero-based position in the <paramref name="buffer"/> parameter at which to
/// start storing data.
/// </param>
/// <param name="size">
/// The number of bytes to receive.
/// </param>
/// <param name="socketFlags">
/// A bitwise combination of the <see cref="SocketFlags"/> values.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> which can be used to cancel the asynchronous task.
/// </param>
/// <remarks>
/// Cancelling the task will also close the socket.
/// </remarks>
/// <returns>
/// The number of bytes received.
/// </returns>
public static Task<int> ReceiveAsync(
this Socket socket,
byte[] buffer,
int offset,
int size,
SocketFlags socketFlags,
CancellationToken cancellationToken)
{
var tcs = new TaskCompletionSource<int>(socket);
// Register a callback so that when a cancellation is requested, the socket is closed.
// This will cause an ObjectDisposedException to bubble up via TrySetResult, which we can catch
// and convert to a TaskCancelledException - which is the exception we expect.
cancellationToken.Register(() => socket.Close());
socket.BeginReceive(
buffer,
offset,
size,
socketFlags,
iar =>
{
var t = (TaskCompletionSource<int>)iar.AsyncState;
var s = (Socket)t.Task.AsyncState;
try
{
t.TrySetResult(s.EndReceive(iar));
}
catch (Exception ex)
{
// Did the cancellationToken's request for cancellation cause the socket to be closed
// and an ObjectDisposedException to be thrown? If so, indicate the caller that we were
// cancelled. If not, bubble up the original exception.
if (ex is ObjectDisposedException && cancellationToken.IsCancellationRequested)
{
t.TrySetCanceled();
}
else
{
t.TrySetException(ex);
}
}
},
tcs);
return tcs.Task;
}
public static Task<Either<int, SocketError>> ReceiveNonBlocking(this Socket s, ArraySegment<byte> buf, SocketFlags flags)
{
SocketError err;
var tcs = new TaskCompletionSource<Either<int, SocketError>>();
try
{
IAsyncResult r = s.BeginReceive(buf.Array, buf.Offset, buf.Count, flags, out err, iar =>
{
try
{
SocketError errInner;
int n = s.EndReceive(iar, out errInner);
if (n <= 0)
tcs.SetResult(errInner);
else
tcs.SetResult(n);
}
catch (SocketException skex)
{
tcs.SetResult(skex.SocketErrorCode);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}, (object)null);
if (r == null)
tcs.SetResult(err);
}
catch (SocketException skex)
{
tcs.SetResult(skex.SocketErrorCode);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
return tcs.Task;
}
public static Future<Network.UdpPacket> AsyncReceive(this UdpClient udpClient)
{
var f = new Future<Network.UdpPacket>();
try {
udpClient.BeginReceive((ar) => {
IPEndPoint endpoint = default(IPEndPoint);
try {
var bytes = udpClient.EndReceive(ar, ref endpoint);
f.Complete(new Network.UdpPacket(bytes, endpoint));
} catch (FutureHandlerException) {
throw;
} catch (Exception ex) {
f.Fail(ex);
}
}, null);
} catch (Exception ex) {
f.Fail(ex);
}
return f;
}
/// <summary>
/// Extends BeginReceive so that when a state object is not needed, null does not need to be passed.
/// <example>
/// socket.BeginReceive(buffers, socketFlags, errorCode, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginReceive(this Socket socket, System.Collections.Generic.IList<ArraySegment<Byte>> buffers, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback)
{
if(socket == null) throw new ArgumentNullException("socket");
return socket.BeginReceive(buffers, socketFlags, out errorCode, callback, null);
}
/// <summary>
/// Extends BeginReceive so that buffer offset of 0 and call to Array.Length are not needed.
/// <example>
/// socket.BeginReceive(buffer, socketFlags, errorCode, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginReceive(this Socket socket, Byte[] buffer, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback)
{
if(socket == null) throw new ArgumentNullException("socket");
if(buffer == null) throw new ArgumentNullException("buffer");
return socket.BeginReceive(buffer, 0, buffer.Length, socketFlags, out errorCode, callback);
}
/// <summary>
/// Extends BeginReceive so that when a state object is not needed, null does not need to be passed.
/// <example>
/// socket.BeginReceive(buffer, offset, size, socketFlags, errorCode, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginReceive(this Socket socket, Byte[] buffer, Int32 offset, Int32 size, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback)
{
if(socket == null) throw new ArgumentNullException("socket");
return socket.BeginReceive(buffer, offset, size, socketFlags, out errorCode, callback, null);
}
/// <summary> /// BeginReceive /// </summary> /// <param name="socket"></param> /// <param name="buffer"></param> /// <param name="callback"></param> /// <returns></returns> public static IAsyncResult BeginReceive(this Socket socket, byte[] buffer, AsyncCallback callback) => socket.BeginReceive(buffer, callback, null);
public static void ReceiveAPM(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags flags, Action<int> handler)
{
var callback = new AsyncCallback(asyncResult => handler(((Socket)asyncResult.AsyncState).EndReceive(asyncResult)));
socket.BeginReceive(buffers, flags, callback, socket);
}
/// <summary>
/// Extends BeginReceive so that when a state object is not needed, null does not need to be passed.
/// <example>
/// udpclient.BeginReceive(requestCallback);
/// </example>
/// </summary>
public static IAsyncResult BeginReceive(this UdpClient udpclient, AsyncCallback requestCallback)
{
if(udpclient == null) throw new ArgumentNullException("udpclient");
return udpclient.BeginReceive(requestCallback, null);
}
public static Task<int> ReceiveTaskAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags = SocketFlags.None)
{
return Task.Factory.FromAsync<int>(socket.BeginReceive(buffer, offset, size, flags, null, socket), socket.EndReceive);
}
public static async Task<int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags socketFlags)
{
return await Task<int>.Factory.FromAsync((callback, state) => socket.BeginReceive(buffer, offset, size, socketFlags, callback, state), ias => socket.EndReceive(ias), null);
}
public static void AsyncReceive(this Socket socket, byte[] buffer)
{
socket.BeginReceive(buffer, 0, buffer.Length, 0, new AsyncCallback(ReceiveCallback), new State() { Socket = socket, Callback = null });
}
public static Task<int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int count, SocketFlags flags = SocketFlags.None)
{
if (socket == null)
throw new ArgumentNullException("socket");
var tcs = new TaskCompletionSource<int>();
socket.BeginReceive(buffer, offset, count, flags, result =>
{
try
{
var s = result.AsyncState as Socket;
var numberOfBytesReceived = s.EndReceive(result);
tcs.SetResult(numberOfBytesReceived);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}, socket);
return tcs.Task;
}
/// <summary> /// BeginReceive /// </summary> /// <param name="socket"></param> /// <param name="buffer"></param> /// <param name="callback"></param> /// <param name="state"></param> /// <returns></returns> public static IAsyncResult BeginReceive(this Socket socket, byte[] buffer, AsyncCallback callback, object state) => socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, callback, state);
