/// <summary> /// Initiates an asynchronous call to the HTTP handler. /// </summary> /// <returns> /// An <see cref="T:System.IAsyncResult"/> that contains information about the status of the process. /// </returns> /// <param name="context">An <see cref="T:System.Web.HttpContext"/> object that provides references to intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests. </param><param name="cb">The <see cref="T:System.AsyncCallback"/> to call when the asynchronous method call is complete. If <paramref name="cb"/> is null, the delegate is not called. </param><param name="extraData">Any extra data needed to process the request. </param> IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData) { var asyncResult = new SimpleAsyncResult<CapacityTestData>(extraData); ProcessRequestAsync(context, cb, asyncResult); return asyncResult; }
public void IsCompletedProperty() { // Arrange SimpleAsyncResult asyncResult = new SimpleAsyncResult(null); // Act bool isCompleted = asyncResult.IsCompleted; // Assert Assert.IsFalse(isCompleted, "IsCompleted should default to false."); }
public void AsyncWaitHandleProperty() { // Arrange SimpleAsyncResult asyncResult = new SimpleAsyncResult(null); // Act WaitHandle asyncWaitHandle = asyncResult.AsyncWaitHandle; // Assert Assert.IsNull(asyncWaitHandle); }
public void CompletedSynchronouslyProperty() { // Arrange SimpleAsyncResult asyncResult = new SimpleAsyncResult(null); // Act bool completedSynchronously = asyncResult.CompletedSynchronously; // Assert Assert.IsFalse(completedSynchronously, "CompletedSynchronously should default to false."); }
public void AsyncStateProperty() { // Arrange string expected = "Hello!"; SimpleAsyncResult asyncResult = new SimpleAsyncResult(expected); // Act object asyncState = asyncResult.AsyncState; // Assert Assert.AreEqual(expected, asyncState); }
public void CompletedSynchronouslyProperty() { // Arrange SimpleAsyncResult asyncResult = new SimpleAsyncResult(null); // Act bool completedSynchronously = asyncResult.CompletedSynchronously; // Assert Assert.False(completedSynchronously); }
private bool SetHeadersAsync(SimpleAsyncResult result, bool setInternalLength) { if (headersSent) { return(false); } string method = request.Method; bool no_writestream = (method == "GET" || method == "CONNECT" || method == "HEAD" || method == "TRACE"); bool webdav = (method == "PROPFIND" || method == "PROPPATCH" || method == "MKCOL" || method == "COPY" || method == "MOVE" || method == "LOCK" || method == "UNLOCK"); if (setInternalLength && !no_writestream && writeBuffer != null) { request.InternalContentLength = writeBuffer.Length; } if (!(sendChunked || request.ContentLength > -1 || no_writestream || webdav)) { return(false); } headersSent = true; headers = request.GetRequestHeaders(); var innerResult = cnc.BeginWrite(request, headers, 0, headers.Length, r => { try { cnc.EndWrite(request, true, r); if (!initRead) { initRead = true; WebConnection.InitRead(cnc); } var cl = request.ContentLength; if (!sendChunked && cl == 0) { requestWritten = true; } result.SetCompleted(false); } catch (WebException e) { result.SetCompleted(false, e); } catch (Exception e) { result.SetCompleted(false, new WebException("Error writing headers", e, WebExceptionStatus.SendFailure)); } }, null); return(innerResult != null); }
public void IsCompletedProperty() { // Arrange SimpleAsyncResult asyncResult = new SimpleAsyncResult(null); // Act bool isCompleted = asyncResult.IsCompleted; // Assert Assert.False(isCompleted); }
public void AsyncStateProperty() { // Arrange string expected = "Hello!"; SimpleAsyncResult asyncResult = new SimpleAsyncResult(expected); // Act object asyncState = asyncResult.AsyncState; // Assert Assert.Equal(expected, asyncState); }
public override object EndRunOperation(IAsyncResult result) { using (SimpleAsyncResult res = result as SimpleAsyncResult) { if (res == null) { throw new ArgumentException("AsyncResult empty!", "result"); } res.EndDisableLoadBalancing(); return(null); } }
public static IAsyncResult BeginSynchronous <TResult>(AsyncCallback callback, object state, Func <TResult> func, object tag) { BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { var result2 = new SimpleAsyncResult(asyncState); result2.MarkCompleted(true, asyncCallback); return(result2); }; EndInvokeDelegate <TResult> endDelegate = (_ => func()); var result = new WrappedAsyncResult <TResult>(beginDelegate, endDelegate, tag); result.Begin(callback, state, -1); return(result); }
public void MarkCompleted_SynchronousCompletion() { // Arrange SimpleAsyncResult asyncResult = new SimpleAsyncResult(null); bool callbackWasCalled = false; AsyncCallback callback = ar => { callbackWasCalled = true; Assert.AreEqual(asyncResult, ar, "Wrong IAsyncResult passed to callback."); Assert.IsTrue(ar.IsCompleted, "IsCompleted property should have been true."); Assert.IsTrue(ar.CompletedSynchronously, "CompletedSynchronously property should have been true."); }; // Act & assert asyncResult.MarkCompleted(true, callback); Assert.IsTrue(callbackWasCalled); }
public static void Run(SimpleAsyncFunc func, SimpleAsyncCallback callback) { var result = new SimpleAsyncResult(callback); try { if (!func(result)) { result.SetCompleted(true); } } catch (Exception ex) { result.SetCompleted(true, ex); } }
public IAsyncResult BeginGetCustomerDetails(int customerId, AsyncCallback callback, object state) { var asyncResult = new SimpleAsyncResult<Customer>(state); // mimic a long running operation var timer = new System.Timers.Timer(DelayMilliseconds); timer.Elapsed += (_, args) => { asyncResult.Result = GetCustomer(customerId); asyncResult.IsCompleted = true; callback(asyncResult); timer.Enabled = false; timer.Close(); }; timer.Enabled = true; return asyncResult; }
public IAsyncResult BeginGetStations(string city, AsyncCallback callback, object state) { var asyncResult = new SimpleAsyncResult <string[]>(state); var timer = new System.Timers.Timer(DelayMilliseconds); timer.Elapsed += (_, args) => { asyncResult.Result = GetStations(city); asyncResult.IsCompleted = true; callback(asyncResult); timer.Enabled = false; timer.Close(); }; timer.Enabled = true; return(asyncResult); }
async void ProcessRequestAsync(HttpContext context, AsyncCallback cb, SimpleAsyncResult<CapacityTestData> asyncResult) { try { CapacityTestData data = await _tsService.WriteToStorageAsyncCtp(); SyncHandler.WriteResultsToResponse(context.Response, data); asyncResult.Result = data; } catch (Exception ex) { asyncResult.Exception = ex; } if (cb != null) cb(asyncResult); }
public IAsyncResult BeginGetCustomerDetails(int customerId, AsyncCallback callback, object state) { var asyncResult = new SimpleAsyncResult <Customer>(state); // mimic a long running operation var timer = new System.Timers.Timer(DelayMilliseconds); timer.Elapsed += (_, args) => { asyncResult.Result = GetCustomer(customerId); asyncResult.IsCompleted = true; callback(asyncResult); timer.Enabled = false; timer.Close(); }; timer.Enabled = true; return(asyncResult); }
public void MarkCompleted_SynchronousCompletion() { // Arrange SimpleAsyncResult asyncResult = new SimpleAsyncResult(null); bool callbackWasCalled = false; AsyncCallback callback = ar => { callbackWasCalled = true; Assert.Equal(asyncResult, ar); Assert.True(ar.IsCompleted); Assert.True(ar.CompletedSynchronously); }; // Act & assert asyncResult.MarkCompleted(true, callback); Assert.True(callbackWasCalled); }
public IAsyncResult BeginGetNbVelibInStations(string stationsName, AsyncCallback callback, object state) { var asyncResult = new SimpleAsyncResult <List <string> >(state); // mimic a long running operation var timer = new System.Timers.Timer(DelayMilliseconds); timer.Elapsed += (_, args) => { asyncResult.Result = GetNbVelibInStations(stationsName); asyncResult.IsCompleted = true; callback(asyncResult); timer.Enabled = false; timer.Close(); }; timer.Enabled = true; return(asyncResult); }
IAsyncResult IAsyncRelayTransport.BeginSendMessage(RelayMessage message, bool forceRoundTrip, AsyncCallback callback, object state) { var result = new SimpleAsyncResult(callback, state); if (forceRoundTrip) { ThreadPool.QueueUserWorkItem(o => { ((IRelayTransportExtended)this).SendSyncMessage(message); result.SetComplete(); }); return(result); } ThreadPool.QueueUserWorkItem(o => { ((IRelayTransport)this).SendMessage(message); result.SetComplete(); }); return(result); }
public IAsyncResult BeginGetCustomerDetails(int customerId, AsyncCallback callback, object state) { var asyncResult = new SimpleAsyncResult<Customer>(state); var channelFactory = new ChannelFactory<ICustomerService>( new BasicHttpBinding(), new EndpointAddress(serviceUri)); var customerService = channelFactory.CreateChannel(); customerService.BeginGetCustomerDetails(customerId, serviceAsyncResult => { try { asyncResult.Result = customerService.EndGetCustomerDetails(serviceAsyncResult); } catch (Exception) { asyncResult.Result = new Customer(0, "Error"); } asyncResult.IsCompleted = true; callback(asyncResult); }, null); return asyncResult; }
public IAsyncResult BeginInvoke(Delegate method, object[] args) { var result = new SimpleAsyncResult(); ThreadPool.QueueUserWorkItem( delegate { result.AsyncWaitHandle = new ManualResetEvent(false); try { result.AsyncState = Invoke(method, args); } catch (Exception exception) { Debug.WriteLine(exception.Message); Debug.WriteLine(exception.StackTrace); result.Exception = exception; } result.IsCompleted = true; }); return(result); }
IAsyncResult IAsyncRelayTransport.BeginSendMessageList(List <RelayMessage> messages, AsyncCallback callback, object state) { var result = new SimpleAsyncResult(callback, state); if (messages.Count == 0) { result.SetComplete(); return(result); } ThreadPool.QueueUserWorkItem(o => { if (messages[0].IsTwoWayMessage) { ((IRelayTransport)this).SendOutMessageList(messages); } else { ((IRelayTransportExtended)this).SendSyncMessageList(messages); } result.SetComplete(); }); return(result); }
internal void SetHeadersAsync(bool setInternalLength, SimpleAsyncCallback callback) { SimpleAsyncResult.Run(r => SetHeadersAsync(r, setInternalLength), callback); }
internal bool WriteRequestAsync(SimpleAsyncResult result) { if (requestWritten) { return(false); } requestWritten = true; if (sendChunked || !allowBuffering || writeBuffer == null) { return(false); } // Keep the call for a potential side-effect of GetBuffer var bytes = writeBuffer.GetBuffer(); var length = (int)writeBuffer.Length; if (request.ContentLength != -1 && request.ContentLength < length) { nextReadCalled = true; cnc.Close(true); throw new WebException("Specified Content-Length is less than the number of bytes to write", null, WebExceptionStatus.ServerProtocolViolation, null); } SetHeadersAsync(true, inner => { if (inner.GotException) { result.SetCompleted(inner.CompletedSynchronously, inner.Exception); return; } if (cnc.Data.StatusCode != 0 && cnc.Data.StatusCode != 100) { result.SetCompleted(inner.CompletedSynchronously); return; } if (!initRead) { initRead = true; WebConnection.InitRead(cnc); } if (length == 0) { complete_request_written = true; result.SetCompleted(inner.CompletedSynchronously); return; } cnc.BeginWrite(request, bytes, 0, length, r => { try { complete_request_written = cnc.EndWrite(request, false, r); result.SetCompleted(false); } catch (Exception exc) { result.SetCompleted(false, exc); } }, null); }); return(true); }
private static IAsyncResult BeginInvokeAction_MakeSynchronousAsyncResult(AsyncCallback callback, object state) { SimpleAsyncResult simpleAsyncResult = new SimpleAsyncResult(state); simpleAsyncResult.MarkCompleted(true, callback); return simpleAsyncResult; }