protected virtual void EndExecute(IAsyncResult asyncResult) { AsyncResultWrapper.End(asyncResult, _executeTag); }
/// <summary> /// Begins an asynchronous version of <see cref="GetErrors"/>. /// </summary> public override IAsyncResult BeginGetErrors(int pageIndex, int pageSize, ICollection<ErrorLogEntry> errorEntryList, AsyncCallback asyncCallback, object asyncState) { if (pageIndex < 0) throw new ArgumentOutOfRangeException("pageIndex", pageIndex, null); if (pageSize < 0) throw new ArgumentOutOfRangeException("pageSize", pageSize, null); // // Modify the connection string on the fly to support async // processing otherwise the asynchronous methods on the // SqlCommand will throw an exception. This ensures the // right behavior regardless of whether configured // connection string sets the Async option to true or not. // var csb = new SqlConnectionStringBuilder(ConnectionString) { AsynchronousProcessing = true }; var connection = new SqlConnection(csb.ConnectionString); // // Create the command object with input parameters initialized // and setup to call the stored procedure. // var command = Commands.GetErrorsXml(ApplicationName, pageIndex, pageSize); command.Connection = connection; // // Create a closure to handle the ending of the async operation // and retrieve results. // AsyncResultWrapper asyncResult = null; Func<IAsyncResult, int> endHandler = delegate { Debug.Assert(asyncResult != null); using (connection) using (command) { var xml = ReadSingleXmlStringResult(command.EndExecuteReader(asyncResult.InnerResult)); ErrorsXmlToList(xml, errorEntryList); int total; Commands.GetErrorsXmlOutputs(command, out total); return total; } }; // // Open the connenction and execute the command asynchronously, // returning an IAsyncResult that wrap the downstream one. This // is needed to be able to send our own AsyncState object to // the downstream IAsyncResult object. In order to preserve the // one sent by caller, we need to maintain and return it from // our wrapper. // try { connection.Open(); asyncResult = new AsyncResultWrapper( command.BeginExecuteReader( asyncCallback != null ? /* thunk */ delegate { asyncCallback(asyncResult); } : (AsyncCallback) null, endHandler), asyncState); return asyncResult; } catch (Exception) { connection.Dispose(); throw; } }
protected internal virtual void EndProcessRequest(IAsyncResult asyncResult) { SecurityUtil.ProcessInApplicationTrust(() => { AsyncResultWrapper.End(asyncResult, _processRequestTag); }); }
/// <summary> /// Begins an asynchronous version of <see cref="GetErrors"/>. /// </summary> public override IAsyncResult BeginGetErrors(int pageIndex, int pageSize, ICollection <ErrorLogEntry> errorEntryList, AsyncCallback asyncCallback, object asyncState) { if (pageIndex < 0) { throw new ArgumentOutOfRangeException("pageIndex", pageIndex, null); } if (pageSize < 0) { throw new ArgumentOutOfRangeException("pageSize", pageSize, null); } // // Modify the connection string on the fly to support async // processing otherwise the asynchronous methods on the // SqlCommand will throw an exception. This ensures the // right behavior regardless of whether configured // connection string sets the Async option to true or not. // var csb = new SqlConnectionStringBuilder(ConnectionString) { AsynchronousProcessing = true }; var connection = new SqlConnection(csb.ConnectionString); // // Create the command object with input parameters initialized // and setup to call the stored procedure. // var command = Commands.GetErrorsXml(ApplicationName, pageIndex, pageSize); command.Connection = connection; // // Create a closure to handle the ending of the async operation // and retrieve results. // AsyncResultWrapper asyncResult = null; Func <IAsyncResult, int> endHandler = delegate { Debug.Assert(asyncResult != null); using (connection) using (command) { var xml = ReadSingleXmlStringResult(command.EndExecuteReader(asyncResult.InnerResult)); ErrorsXmlToList(xml, errorEntryList); int total; Commands.GetErrorsXmlOutputs(command, out total); return(total); } }; // // Open the connenction and execute the command asynchronously, // returning an IAsyncResult that wrap the downstream one. This // is needed to be able to send our own AsyncState object to // the downstream IAsyncResult object. In order to preserve the // one sent by caller, we need to maintain and return it from // our wrapper. // try { connection.Open(); asyncResult = new AsyncResultWrapper( command.BeginExecuteReader( asyncCallback != null ? /* thunk */ delegate { asyncCallback(asyncResult); } : (AsyncCallback)null, endHandler), asyncState); return(asyncResult); } catch (Exception) { connection.Dispose(); throw; } }
protected internal virtual void EndProcessRequest(IAsyncResult asyncResult) { AsyncResultWrapper.End(asyncResult, _processRequestTag); }
public void End_ThrowsIfAsyncResultIsNull() { // Act & assert Assert.ThrowsArgumentNull( delegate { AsyncResultWrapper.End(null); }, "asyncResult"); }
protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state) { IController controller; IControllerFactory factory; ProcessRequestInit(httpContext, out controller, out factory); IAsyncController asyncController = controller as IAsyncController; if (asyncController != null) { // asynchronous controller // Ensure delegates continue to use the C# Compiler static delegate caching optimization. BeginInvokeDelegate <ProcessRequestState> beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState, ProcessRequestState innerState) { try { return(innerState.AsyncController.BeginExecute(innerState.RequestContext, asyncCallback, asyncState)); } catch { innerState.ReleaseController(); throw; } }; EndInvokeVoidDelegate <ProcessRequestState> endDelegate = delegate(IAsyncResult asyncResult, ProcessRequestState innerState) { try { innerState.AsyncController.EndExecute(asyncResult); } finally { innerState.ReleaseController(); } }; ProcessRequestState outerState = new ProcessRequestState() { AsyncController = asyncController, Factory = factory, RequestContext = RequestContext }; SynchronizationContext callbackSyncContext = SynchronizationContextUtil.GetSynchronizationContext(); return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, outerState, _processRequestTag, callbackSyncContext: callbackSyncContext)); } else { // synchronous controller Action action = delegate { try { controller.Execute(RequestContext); } finally { factory.ReleaseController(controller); } }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _processRequestTag)); } }