public async Task NegotiateStream_EndReadEndWriteInvalidParameter_Throws()
{
byte[] recvBuf = new byte[s_sampleMsg.Length];
(Stream stream1, Stream stream2) = ConnectedStreams.CreateBidirectional();
using (var client = new NegotiateStream(stream1))
using (var server = new NegotiateStream(stream2))
{
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
client.AuthenticateAsClientAsync(CredentialCache.DefaultNetworkCredentials, string.Empty),
server.AuthenticateAsServerAsync());
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
Task.Factory.FromAsync(client.BeginWrite,
(asyncResult) =>
{
NegotiateStream authStream = (NegotiateStream)asyncResult.AsyncState;
AssertExtensions.Throws <ArgumentNullException>(nameof(asyncResult), () => authStream.EndWrite(null));
IAsyncResult result = new MyAsyncResult();
AssertExtensions.Throws <ArgumentException>(nameof(asyncResult), () => authStream.EndWrite(result));
},
s_sampleMsg, 0, s_sampleMsg.Length, client),
Task.Factory.FromAsync(server.BeginRead,
(asyncResult) =>
{
NegotiateStream authStream = (NegotiateStream)asyncResult.AsyncState;
AssertExtensions.Throws <ArgumentNullException>(nameof(asyncResult), () => authStream.EndRead(null));
IAsyncResult result = new MyAsyncResult();
AssertExtensions.Throws <ArgumentException>(nameof(asyncResult), () => authStream.EndRead(result));
},
recvBuf, 0, s_sampleMsg.Length, server));
}
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback callback, object state)
{
var action = Interlocked.Exchange(ref writeAction, null);
if (action == null)
{
return(base.BeginWrite(buffer, offset, size, callback, state));
}
if (action.Action != null)
{
action.Action();
return(base.BeginWrite(buffer, offset, size, callback, state));
}
var myResult = new MyAsyncResult(action, callback, state);
var transportResult = base.BeginWrite(buffer, offset, size, WriteCallback, myResult);
if (transportResult.CompletedSynchronously)
{
Task.Factory.StartNew(() => WriteCallback(transportResult));
}
return(myResult);
}
public void EndProcessRequest(IAsyncResult result)
{
MyAsyncResult rslt = (MyAsyncResult)result;
rslt.Context.Response.Write(SerializerHelper.ToJson(rslt.Msg));
rslt.Msg.Content = string.Empty;
}
public async Task NegotiateStream_EndAuthenticateInvalidParameter_Throws()
{
var network = new VirtualNetwork();
using (var clientStream = new VirtualNetworkStream(network, isServer: false))
using (var serverStream = new VirtualNetworkStream(network, isServer: true))
using (var client = new NegotiateStream(clientStream))
using (var server = new NegotiateStream(serverStream))
{
await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
Task.Factory.FromAsync(client.BeginAuthenticateAsClient, (asyncResult) =>
{
NegotiateStream authStream = (NegotiateStream)asyncResult.AsyncState;
AssertExtensions.Throws <ArgumentNullException>(nameof(asyncResult), () => authStream.EndAuthenticateAsClient(null));
IAsyncResult result = new MyAsyncResult();
AssertExtensions.Throws <ArgumentException>(nameof(asyncResult), () => authStream.EndAuthenticateAsClient(result));
authStream.EndAuthenticateAsClient(asyncResult);
}, CredentialCache.DefaultNetworkCredentials, string.Empty, client),
Task.Factory.FromAsync(server.BeginAuthenticateAsServer, (asyncResult) =>
{
NegotiateStream authStream = (NegotiateStream)asyncResult.AsyncState;
AssertExtensions.Throws <ArgumentNullException>(nameof(asyncResult), () => authStream.EndAuthenticateAsServer(null));
IAsyncResult result = new MyAsyncResult();
AssertExtensions.Throws <ArgumentException>(nameof(asyncResult), () => authStream.EndAuthenticateAsServer(result));
authStream.EndAuthenticateAsServer(asyncResult);
}, server));
}
}
static IAsyncResult Begin(int x, AsyncCallback callback, object state)
{
Thread th = new Thread(MyTask);
MyAsyncResult ar = new MyAsyncResult(x, callback, state);
th.Start(ar);
return(ar);
}
static int End(IAsyncResult ar)
{
MyAsyncResult mar = (MyAsyncResult)ar;
mar.AsyncWaitHandle.WaitOne();
return(mar.Result); // will throw exception if one
// occurred in background task
}
private static void OnSocketCallback(IAsyncResult asyncResult)
{
MyAsyncResult receiveAsyncResult = asyncResult.AsyncState as MyAsyncResult;
if ((receiveAsyncResult != null) && (receiveAsyncResult.Callback != null))
{
receiveAsyncResult.AsyncResult = asyncResult;
receiveAsyncResult.Callback(receiveAsyncResult);
}
}
public int EndDivide(IAsyncResult result)
{
MyAsyncResult internalResult = (MyAsyncResult)result;
if (internalResult.Exception != null)
{
throw internalResult.Exception;
}
return(internalResult.Result);
}
public void CancelSort(IAsyncResult asyncResult)
{
MyAsyncResult target = asyncResult as MyAsyncResult;
if (target == null)
{
throw new ArgumentException();
}
target.Cancel = true;
}
public void EndSort(IAsyncResult asyncResult)
{
MyAsyncResult target = asyncResult as MyAsyncResult;
if (target == null)
{
throw new ArgumentException();
}
// Add code here to extract any additional information from the IAsyncResult that
// you might want to return to the client. Perhaps this method will be empty.
}
public int EndSend(IAsyncResult asyncResult)
{
MyAsyncResult receiveAsyncResult = asyncResult as MyAsyncResult;
if (receiveAsyncResult == null)
{
throw new ArgumentException("Invalid Async Result", "asyncResult");
}
return(_socket.EndSendTo(receiveAsyncResult.AsyncResult));
}
public IAsyncResult BeginSend(byte[] buffer, int offset, int length, IPEndPoint endPoint, AsyncCallback callback, object state)
{
MyAsyncResult result =
new MyAsyncResult()
{
Callback = callback,
State = state
};
result.AsyncResult = _socket.BeginSendTo(buffer, offset, length, SocketFlags.None, endPoint, OnSocketCallback, result);
return result;
}
public IAsyncResult BeginSend(byte[] buffer, int offset, int length, IPEndPoint endPoint, AsyncCallback callback, object state)
{
MyAsyncResult result =
new MyAsyncResult()
{
Callback = callback,
State = state
};
result.AsyncResult = _socket.BeginSendTo(buffer, offset, length, SocketFlags.None, endPoint, OnSocketCallback, result);
return(result);
}
public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
{
// 当 cb 被调用时，其内部将会调用 EndProcesssRequest 方法
// 同时完成 HTTP 最后响应的处理从而完成整个请求
// 这个方法应该快速返回，避免阻塞线程
// 此行代码返回后，IIS 工作线程将会返回线程池中，处理其它的 HTTP 请求
// MyAsyncResult 中的数据处理完成后，应该调用 cb 回调
// cb 回调将会在内部调用 EndProcessRequest 完成最后的处理
// 返回的是一个 MyAsyncResult
// 执行 cb 时的回调参数，也要是同一对象
myResult = new MyAsyncResult(context, cb, extraData);
return myResult;
}
static void MyTask(object param)
{
MyAsyncResult ar = (MyAsyncResult)param;
try
{
int x = ar.X;
Thread.Sleep(1000); // simulate lengthy work
ar.SignalDone(x * 2); // demo work = double X
}
catch (Exception ex)
{
ar.SignalException(ex);
}
}
public IAsyncResult BeginReceive(AsyncCallback callback, object state)
{
MyAsyncResult result =
new MyAsyncResult()
{
Buffer = new byte[65535],
EndPoint = _endPoint,
Callback = callback,
State = state
};
result.AsyncResult = _socket.BeginReceiveFrom(result.Buffer, 0, 65535, SocketFlags.None, ref result.EndPoint, OnSocketCallback, result);
return result;
}
public IAsyncResult BeginReceive(AsyncCallback callback, object state)
{
MyAsyncResult result =
new MyAsyncResult()
{
Buffer = new byte[65535],
EndPoint = _endPoint,
Callback = callback,
State = state
};
result.AsyncResult = _socket.BeginReceiveFrom(result.Buffer, 0, 65535, SocketFlags.None, ref result.EndPoint, OnSocketCallback, result);
return(result);
}
public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
{
context.Response.Cache.SetCacheability(HttpCacheability.NoCache);
int mid = int.Parse(context.Request.QueryString["mid"]);
if (CometManager.Clients.Keys.Contains(mid))
{
CometManager.Clients[mid].Context = context;
CometManager.Clients[mid].CallBack = cb;
return(CometManager.Clients[mid]);
}
MyAsyncResult asyncResult = new MyAsyncResult(context, cb, mid);
CometManager.Clients[mid] = asyncResult;
return(asyncResult);
}
public IAsyncResult BeginSort(IList <T> values, AsyncCallback complete)
{
MyAsyncResult asyncResult = new MyAsyncResult();
Thread t = new Thread(() =>
{
// Implement your sorting algorithm here.
// Periodically check asyncResult.Cancel at safe points.
asyncResult.Complete();
if (complete != null)
{
complete(asyncResult);
}
});
t.Start();
return(asyncResult);
}
public IAsyncResult BeginDivide(int nominator, int denominator,
AsyncCallback callback, object state)
{
MyAsyncResult result = new MyAsyncResult(callback, state);
ThreadPool.QueueUserWorkItem(cb =>
{
Thread.Sleep(10000);
try
{
result.Result = nominator / denominator;
}
catch (Exception ex)
{
result.Exception = ex;
}
result.Complete();
});
return(result);
}
public void run()
{
if (log.isDebugEnabled())
{
log.debug("run(");
}
MyAsyncResult asyncResult = new MyAsyncResult(pthis);
BAsyncResultIF <BMessage> nextAsyncMethod = new MyAsyncMethod(pthis, asyncResult);
// Sende den longPoll-Request
// Im Body befindet sich die Antwort auf die vorige vom Server gestellte Anfrage.
// Als Ergebnis des longPoll kommt eine neue Serveranfrage (Methode).
pthis.transport.getWire().sendR(methodResult, nextAsyncMethod);
if (log.isDebugEnabled())
{
log.debug(")run");
}
}
public IAsyncResult BeginGetComputers(AsyncCallback callback, object state)
{
var entities = new CrmEntitiesEntities();
var query = (from comp in entities.Computers
where comp.Id > 10 && comp.Id < 100
orderby comp.Id
select comp).Skip(10).Take(25);
var result = new MyAsyncResult <Computer[]> {
AsyncState = state
};
entities.BeginGetEntities(query, entitiesAsyncResult =>
{
IEnumerable <Computer> computers = entities.EndGetEntities <Computer>(entitiesAsyncResult);
result.Data = computers.ToArray();
entities.Dispose();
result.Complete(false);
callback(result);
}, null);
return(result);
#region TPL Improvements
var task = Task.Factory.FromAsync <IQueryable <Computer>, IEnumerable <Computer> >(
entities.BeginGetEntities, entities.EndGetEntities <Computer>, query, state);
return(task.ContinueWith(res =>
{
entities.Dispose();
callback(task);
}));
#endregion
}
public byte[] EndReceive(IAsyncResult asyncResult, out IPEndPoint endPoint)
{
MyAsyncResult receiveAsyncResult = asyncResult as MyAsyncResult;
if (receiveAsyncResult == null)
{
throw new ArgumentException("Invalid Async Result", "asyncResult");
}
int length = _socket.EndReceiveFrom(receiveAsyncResult.AsyncResult, ref receiveAsyncResult.EndPoint);
endPoint = receiveAsyncResult.EndPoint as IPEndPoint;
if (length == 65535)
{
return(receiveAsyncResult.Buffer);
}
else
{
byte[] result = new byte[length];
Buffer.BlockCopy(receiveAsyncResult.Buffer, 0, result, 0, length);
return(result);
}
}
public MyAsyncMethod(HServerR pthis, MyAsyncResult asyncResult)
{
this.pthis = pthis;
this.asyncResult = asyncResult;
}
