public void ReceiveResponses(ProcessRequestsAsyncCompletedArgs args, Response[] tempResponseArray, Request[] requestsToSendAsArray) { if (args == null) { responseReceivedCallback(new ReceivedResponses(tempResponseArray, keyToResultPositions)); } else { if (HasException(args)) { HandleException(args); } else { var disposable = responseReceivedCallback.Target as Disposable; if (disposable == null || !disposable.IsDisposed) { var receivedResponses = args.Result; AddCacheableResponsesToCache(receivedResponses, requestsToSendAsArray); PutReceivedResponsesInTempResponseArray(tempResponseArray, receivedResponses); responseReceivedCallback(new ReceivedResponses(tempResponseArray, keyToResultPositions)); } } } }
private static bool HasException(ProcessRequestsAsyncCompletedArgs args) { if (args.Error == null) { return(args.Result.Any(r => r.Exception != null)); } return(true); }
private static ExceptionType GetExceptionType(ProcessRequestsAsyncCompletedArgs args) { if (args.Error == null) { var responseWithException = GetFirstException(args.Result); if (responseWithException != null) { return(responseWithException.ExceptionType); } return(ExceptionType.Unknown); } return(ExceptionType.Unknown); }
private static ExceptionInfo GetException(ProcessRequestsAsyncCompletedArgs args) { if (args.Error == null) { var responseWithException = GetFirstException(args.Result); if (responseWithException != null) { return(responseWithException.Exception); } return(null); } return(new ExceptionInfo(args.Error)); }
/// <summary> /// Called when [process requests completed]. /// </summary> /// <param name="processRequestsAsyncCompletedArgs">The process requests async completed args.</param> /// <param name="responseReciever">The response reciever.</param> /// <param name="tempResponseArray">The temp response array.</param> /// <param name="requestsToSendAsArray">The requests to send as array.</param> public override void OnProcessRequestsCompleted( ProcessRequestsAsyncCompletedArgs processRequestsAsyncCompletedArgs, ResponseReceiver responseReciever, Response[] tempResponseArray, Request[] requestsToSendAsArray ) { base.OnProcessRequestsCompleted ( processRequestsAsyncCompletedArgs, responseReciever, tempResponseArray, requestsToSendAsArray ); var requestEndTime = DateTime.Now; var timespan = requestEndTime - _requestStartTime; var requestString = GetRequestString ( requestsToSendAsArray ); Logger.Debug ( "Response received for the following agatha batch: [{0}]. Elapsed milliseconds ({1})", requestString, timespan.TotalMilliseconds ); }
private void HandleException(ProcessRequestsAsyncCompletedArgs args) { var disposable = responseReceivedCallback.Target as Disposable; if (disposable == null || !disposable.IsDisposed) { var exception = GetException(args); if (exceptionOccurredCallback != null) { exceptionOccurredCallback(exception); } else if (exceptionAndTypeOccuredCallback != null) { var exceptionType = GetExceptionType(args); exceptionAndTypeOccuredCallback(exception, exceptionType); } else { responseReceivedCallback(new ReceivedResponses(args.Result, keyToResultPositions)); } } }
public virtual void OnProcessRequestsCompleted(ProcessRequestsAsyncCompletedArgs args, ResponseReceiver responseReciever, Response[] tempResponseArray, Request[] requestsToSendAsArray) { Dispose(); responseReciever.ReceiveResponses(args, tempResponseArray, requestsToSendAsArray); }
protected override void Act() { lastProcessRequestInput = input; lastProcessRequestsThrewException = false; output = null; input.Stub(input.requestResponsePair); asyncRequestProcessor.ProcessRequestsAsync(input.requestResponsePair.Item1, args => output = args); // this uglyness is only here because of the async stuff int counter = 0; while (output == null) { if (++counter == 20) { throw new InvalidOperationException("time out... the callback should've been called already"); } Thread.Sleep(10); } }