internal override void WriteReturns(object[] returnValues, Stream outputStream) { try { if (handler != null) { Context.Items.Add("wsdls", serverType.ServiceDescriptions); Context.Items.Add("schemas", serverType.Schemas); // conditionally add post-enabled wsdls and schemas to support localhost-only post string localAddr = Context.Request.ServerVariables["LOCAL_ADDR"]; string remoteAddr = Context.Request.ServerVariables["REMOTE_ADDR"]; if (Context.Request.Url.IsLoopback || (localAddr != null && remoteAddr != null && localAddr == remoteAddr)) { Context.Items.Add("wsdlsWithPost", serverType.ServiceDescriptionsWithPost); Context.Items.Add("schemasWithPost", serverType.SchemasWithPost); } Response.ContentType = "text/html"; handler.ProcessRequest(Context); } } catch (Exception e) { throw new InvalidOperationException(Res.GetString(Res.HelpGeneratorInternalError), e); } }
// synchronous code protected override void VerifyAndProcessRequest(IHttpHandler httpHandler, HttpContextBase httpContext) { if (httpHandler == null) { throw new ArgumentNullException("httpHandler"); } httpHandler.ProcessRequest(HttpContext.Current); }
//- @ProcessRequest -// public void ProcessRequest(HttpContext context) { Route(context); //+ List <MinimaComponentSetting.MinimaInfo> parameterList = MinimaComponentSetting.CurrentComponentSetting.GetParameterList(); MinimaComponentSetting.MinimaInfo currentInfo = parameterList.FirstOrDefault(u => u.WebSection != null && Http.Url.AbsolutePath.ToLower().Contains(u.WebSection.ToLower())); if (currentInfo != null) { context.Items.Add("BlogPage", currentInfo.Page); } else { currentInfo = parameterList.FirstOrDefault(u => u.WebSection != null && u.WebSection.Equals("Root", StringComparison.InvariantCultureIgnoreCase)); if (currentInfo != null) { context.Items.Add("BlogPage", currentInfo.Page); } else { context.Items.Add("BlogPage", "~/default.aspx"); } } //+ IHttpHandler h = System.Web.UI.PageParser.GetCompiledPageInstance(ContextItemSet.BlogPage, null, context); h.ProcessRequest(context); }
void NormalPage(HttpContext context) { IHttpHandler handler = null; try { handler = PageParser.GetCompiledPageInstance( context.Request.Path, context.Request.PhysicalPath, context); context.Handler = handler; handler.ProcessRequest(context); } catch (System.Threading.ThreadAbortException) { } catch (Exception ex) { context.Response.Write(ex.ToString()); } finally { if (handler != null) { if (handler is IDisposable) { ((IDisposable)handler).Dispose(); } } } }
private static void HandleRequestThread(HttpListenerContext context) { try { foreach (var httpHandlerObj in HttpHandlers) { IHttpHandler httpHandler = httpHandlerObj as IHttpHandler; httpHandler.ProcessRequest(context); } } catch (HttpException exception) { ExceptionHelper.RespondError(context.Response, exception); } catch (Exception exception) { ExceptionHelper.RespondError(context.Response, exception); } finally { if (context != null) { context.Close(); } } }
protected override void VerifyAndProcessRequest(IHttpHandler handler, HttpContextBase context) { Precondition.Require(handler, () => Error.ArgumentNull("handler")); Precondition.Require(context, () => Error.ArgumentNull("context")); handler.ProcessRequest(context.Unwrap()); }
protected override void VerifyAndProcessRequest(IHttpHandler httpHandler, HttpContextBase httpContext) { if (httpHandler == null) { throw new ArgumentNullException("httpHandler"); } httpHandler.ProcessRequest(HttpContext.Current); }
public void GetProcessResult() { foreach (var httpHandlerFactory in _httpHandlerFactories) { IHttpHandler httpHandler = httpHandlerFactory.GetHttpHandler(); if (httpHandler.CanAccept(_context.Request)) { httpHandler.ProcessRequest(_context); } } }
protected override void VerifyAndProcessRequest(IHttpHandler httpHandler, HttpContextBase httpContext) { if (httpHandler == null) { throw new ArgumentNullException("httpHandler"); } var origHttpHandler = httpContext.Handler; try { httpContext.Handler = httpHandler; httpHandler.ProcessRequest(HttpContext.Current); } finally { httpContext.Handler = origHttpHandler; } }
public static string CaptureOutput(this HttpContext ctx, IHttpHandler page) { var old = ctx.Response.Output; try { var writer = new StringWriter(); ctx.Response.Output = writer; page.ProcessRequest(ctx); return writer.ToString(); } finally { ctx.Response.Output = old; } }
public static void ProcessRequest(this IHttpChannel channel, IHttpHandler handler, HttpServerSettings settings) { var context = new HttpContextImpl(channel, settings); var res = context.Response; using (res.OutputStream) { try { var app = handler as ExpressApplication; if (app != null) { if (!app.Process(context)) { res.StatusCode = (int)HttpStatusCode.NotFound; res.StatusDescription = "Not found"; res.ContentType = "text/plain"; res.Write("Resource not found!"); } res.Flush(); res.End(); } else { var workerRequest = new HttpWorkerRequestImpl(context, settings); handler.ProcessRequest(new HttpContext(workerRequest)); workerRequest.EndOfRequest(); } } catch (Exception e) { Console.Error.WriteLine(e); res.StatusCode = (int)HttpStatusCode.InternalServerError; res.ContentType = "text/plain"; res.Write(e.ToString()); } } }
private void ExecuteInternal(IHttpHandler handler, TextWriter writer, bool preserveForm, bool setPreviousPage, VirtualPath path, VirtualPath filePath, string physPath, Exception error, string queryStringOverride) { if (handler == null) { throw new ArgumentNullException("handler"); } HttpRequest request = this._context.Request; HttpResponse response = this._context.Response; HttpApplication applicationInstance = this._context.ApplicationInstance; HttpValueCollection form = null; VirtualPath path2 = null; string queryStringText = null; TextWriter writer2 = null; AspNetSynchronizationContext syncContext = null; this.VerifyTransactionFlow(handler); this._context.PushTraceContext(); this._context.SetCurrentHandler(handler); bool enabled = this._context.SyncContext.Enabled; this._context.SyncContext.Disable(); try { try { this._context.ServerExecuteDepth++; path2 = request.SwitchCurrentExecutionFilePath(filePath); if (!preserveForm) { form = request.SwitchForm(new HttpValueCollection()); if (queryStringOverride == null) { queryStringOverride = string.Empty; } } if (queryStringOverride != null) { queryStringText = request.QueryStringText; request.QueryStringText = queryStringOverride; } if (writer != null) { writer2 = response.SwitchWriter(writer); } Page page = handler as Page; if (page != null) { if (setPreviousPage) { page.SetPreviousPage(this._context.PreviousHandler as Page); } Page page2 = this._context.Handler as Page; if ((page2 != null) && page2.SmartNavigation) { page.SmartNavigation = true; } if (page is IHttpAsyncHandler) { syncContext = this._context.InstallNewAspNetSynchronizationContext(); } } if (((handler is StaticFileHandler) || (handler is DefaultHttpHandler)) && !DefaultHttpHandler.IsClassicAspRequest(filePath.VirtualPathString)) { try { response.WriteFile(physPath); } catch { error = new HttpException(0x194, string.Empty); } } else if (!(handler is Page)) { error = new HttpException(0x194, string.Empty); } else { if (handler is IHttpAsyncHandler) { bool isInCancellablePeriod = this._context.IsInCancellablePeriod; if (isInCancellablePeriod) { this._context.EndCancellablePeriod(); } try { IHttpAsyncHandler handler2 = (IHttpAsyncHandler) handler; IAsyncResult result = handler2.BeginProcessRequest(this._context, null, null); if (!result.IsCompleted) { bool flag3 = false; try { try { } finally { Monitor.Exit(applicationInstance); flag3 = true; } WaitHandle asyncWaitHandle = result.AsyncWaitHandle; if (asyncWaitHandle == null) { goto Label_0210; } asyncWaitHandle.WaitOne(); goto Label_0226; Label_020A: Thread.Sleep(1); Label_0210: if (!result.IsCompleted) { goto Label_020A; } } finally { if (flag3) { Monitor.Enter(applicationInstance); } } } Label_0226: try { handler2.EndProcessRequest(result); } catch (Exception exception) { error = exception; } goto Label_0306; } finally { if (isInCancellablePeriod) { this._context.BeginCancellablePeriod(); } } } using (new DisposableHttpContextWrapper(this._context)) { try { handler.ProcessRequest(this._context); } catch (Exception exception2) { error = exception2; } } } } finally { this._context.ServerExecuteDepth--; this._context.RestoreCurrentHandler(); if (writer2 != null) { response.SwitchWriter(writer2); } if ((queryStringOverride != null) && (queryStringText != null)) { request.QueryStringText = queryStringText; } if (form != null) { request.SwitchForm(form); } request.SwitchCurrentExecutionFilePath(path2); if (syncContext != null) { this._context.RestoreSavedAspNetSynchronizationContext(syncContext); } if (enabled) { this._context.SyncContext.Enable(); } this._context.PopTraceContext(); } } catch { throw; } Label_0306: if (error == null) { return; } if ((error is HttpException) && (((HttpException) error).GetHttpCode() != 500)) { error = null; } if (path != null) { throw new HttpException(System.Web.SR.GetString("Error_executing_child_request_for_path", new object[] { path }), error); } throw new HttpException(System.Web.SR.GetString("Error_executing_child_request_for_handler", new object[] { handler.GetType().ToString() }), error); }
private void ProcessPage(IController controller, IHttpHandler page, HttpContext httpContext) { PreSendView(controller, page); page.ProcessRequest(httpContext); PostSendView(controller, page); }
internal void Execute (IHttpHandler handler, TextWriter writer, bool preserveForm, string exePath, string queryString, bool isTransfer, bool isInclude) { // If the target handler is not Page, the transfer must not occur. // InTransit == true means we're being called from Transfer bool is_static = (handler is StaticFileHandler); if (isTransfer && !(handler is Page) && !is_static) throw new HttpException ("Transfer is only allowed to .aspx and static files"); HttpRequest request = context.Request; string oldQuery = request.QueryStringRaw; if (queryString != null) { request.QueryStringRaw = queryString; } else if (!preserveForm) { request.QueryStringRaw = String.Empty; } HttpResponse response = context.Response; WebROCollection oldForm = request.Form as WebROCollection; if (!preserveForm) { request.SetForm (new WebROCollection ()); } TextWriter output = writer; if (output == null) output = response.Output; TextWriter previous = response.SetTextWriter (output); string oldExePath = request.CurrentExecutionFilePath; bool oldIsInclude = context.IsProcessingInclude; try { context.PushHandler (handler); if (is_static) // Not sure if this should apply to Page too request.SetFilePath (exePath); request.SetCurrentExePath (exePath); context.IsProcessingInclude = isInclude; if (!(handler is IHttpAsyncHandler)) { handler.ProcessRequest (context); } else { IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler) handler; IAsyncResult ar = asyncHandler.BeginProcessRequest (context, null, null); WaitHandle asyncWaitHandle = ar != null ? ar.AsyncWaitHandle : null; if (asyncWaitHandle != null) asyncWaitHandle.WaitOne (); asyncHandler.EndProcessRequest (ar); } } finally { if (oldQuery != request.QueryStringRaw) { if (oldQuery != null && oldQuery.Length > 0) { oldQuery = oldQuery.Substring (1); // Ignore initial '?' request.QueryStringRaw = oldQuery; // which is added here. } else request.QueryStringRaw = String.Empty; } response.SetTextWriter (previous); if (!preserveForm) request.SetForm (oldForm); context.PopHandler (); request.SetCurrentExePath (oldExePath); context.IsProcessingInclude = oldIsInclude; } }
private void ExecuteInternal(IHttpHandler handler, TextWriter writer, bool preserveForm, bool setPreviousPage, VirtualPath path, VirtualPath filePath, string physPath, Exception error, string queryStringOverride) { EnsureHasNotTransitionedToWebSocket(); if (handler == null) throw new ArgumentNullException("handler"); HttpRequest request = _context.Request; HttpResponse response = _context.Response; HttpApplication app = _context.ApplicationInstance; HttpValueCollection savedForm = null; VirtualPath savedCurrentExecutionFilePath = null; string savedQueryString = null; TextWriter savedOutputWriter = null; AspNetSynchronizationContextBase savedSyncContext = null; // Transaction wouldn't flow into ASPCOMPAT mode -- need to report an error VerifyTransactionFlow(handler); // create new trace context _context.PushTraceContext(); // set the new handler as the current handler _context.SetCurrentHandler(handler); // because we call this synchrnously async operations must be disabled bool originalSyncContextWasEnabled = _context.SyncContext.Enabled; _context.SyncContext.Disable(); // Execute the handler try { try { _context.ServerExecuteDepth++; savedCurrentExecutionFilePath = request.SwitchCurrentExecutionFilePath(filePath); if (!preserveForm) { savedForm = request.SwitchForm(new HttpValueCollection()); // Clear out the query string, but honor overrides if (queryStringOverride == null) queryStringOverride = String.Empty; } // override query string if requested if (queryStringOverride != null) { savedQueryString = request.QueryStringText; request.QueryStringText = queryStringOverride; } // capture output if requested if (writer != null) savedOutputWriter = response.SwitchWriter(writer); Page targetPage = handler as Page; if (targetPage != null) { if (setPreviousPage) { // Set the previousPage of the new Page as the previous Page targetPage.SetPreviousPage(_context.PreviousHandler as Page); } Page sourcePage = _context.Handler as Page; #pragma warning disable 0618 // To avoid deprecation warning // If the source page of the transfer has smart nav on, // always do as if the destination has it too (ASURT 97732) if (sourcePage != null && sourcePage.SmartNavigation) targetPage.SmartNavigation = true; #pragma warning restore 0618 // If the target page is async need to save/restore sync context if (targetPage is IHttpAsyncHandler) { savedSyncContext = _context.InstallNewAspNetSynchronizationContext(); } } if ((handler is StaticFileHandler || handler is DefaultHttpHandler) && !DefaultHttpHandler.IsClassicAspRequest(filePath.VirtualPathString)) { // cannot apply static files handler directly // -- it would dump the source of the current page // instead just dump the file content into response try { response.WriteFile(physPath); } catch { // hide the real error as it could be misleading // in case of mismapped requests like /foo.asmx/bar error = new HttpException(404, String.Empty); } } else if (!(handler is Page)) { // disallow anything but pages error = new HttpException(404, String.Empty); } else if (handler is IHttpAsyncHandler) { // Asynchronous handler // suspend cancellable period (don't abort this thread while // we wait for another to finish) bool isCancellable = _context.IsInCancellablePeriod; if (isCancellable) _context.EndCancellablePeriod(); try { IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler)handler; if (!AppSettings.UseTaskFriendlySynchronizationContext) { // Legacy code path: behavior ASP.NET <= 4.0 IAsyncResult ar = asyncHandler.BeginProcessRequest(_context, null, null); // wait for completion if (!ar.IsCompleted) { // suspend app lock while waiting bool needToRelock = false; try { try { } finally { _context.SyncContext.DisassociateFromCurrentThread(); needToRelock = true; } WaitHandle h = ar.AsyncWaitHandle; if (h != null) { h.WaitOne(); } else { while (!ar.IsCompleted) Thread.Sleep(1); } } finally { if (needToRelock) { _context.SyncContext.AssociateWithCurrentThread(); } } } // end the async operation (get error if any) try { asyncHandler.EndProcessRequest(ar); } catch (Exception e) { error = e; } } else { // New code path: behavior ASP.NET >= 4.5 IAsyncResult ar; bool blockedThread; using (CountdownEvent countdownEvent = new CountdownEvent(1)) { using (_context.SyncContext.AcquireThreadLock()) { // Kick off the asynchronous operation ar = asyncHandler.BeginProcessRequest(_context, cb: _ => { countdownEvent.Signal(); }, extraData: null); } // The callback passed to BeginProcessRequest will signal the CountdownEvent. // The Wait() method blocks until the callback executes; no-ops if the operation completed synchronously. blockedThread = !countdownEvent.IsSet; countdownEvent.Wait(); } // end the async operation (get error if any) try { using (_context.SyncContext.AcquireThreadLock()) { asyncHandler.EndProcessRequest(ar); } // If we blocked the thread, YSOD the request to display a diagnostic message. if (blockedThread && !_context.SyncContext.AllowAsyncDuringSyncStages) { throw new InvalidOperationException(SR.GetString(SR.Server_execute_blocked_on_async_handler)); } } catch (Exception e) { error = e; } } } finally { // resume cancelleable period if (isCancellable) _context.BeginCancellablePeriod(); } } else { // Synchronous handler using (new DisposableHttpContextWrapper(_context)) { try { handler.ProcessRequest(_context); } catch (Exception e) { error = e; } } } } finally { _context.ServerExecuteDepth--; // Restore the handlers; _context.RestoreCurrentHandler(); // restore output writer if (savedOutputWriter != null) response.SwitchWriter(savedOutputWriter); // restore overriden query string if (queryStringOverride != null && savedQueryString != null) request.QueryStringText = savedQueryString; if (savedForm != null) request.SwitchForm(savedForm); request.SwitchCurrentExecutionFilePath(savedCurrentExecutionFilePath); if (savedSyncContext != null) { _context.RestoreSavedAspNetSynchronizationContext(savedSyncContext); } if (originalSyncContextWasEnabled) { _context.SyncContext.Enable(); } // restore trace context _context.PopTraceContext(); } } catch { // Protect against exception filters throw; } // Report any error if (error != null) { // suppress errors with HTTP codes (for child requests they mislead more than help) if (error is HttpException && ((HttpException)error).GetHttpCode() != 500) error = null; if (path != null) throw new HttpException(SR.GetString(SR.Error_executing_child_request_for_path, path), error); throw new HttpException(SR.GetString(SR.Error_executing_child_request_for_handler, handler.GetType().ToString()), error); } }
private static HttpResponse ProcessRequest(IHttpHandler page, TextWriter writer) { var response = new HttpResponse(writer); var context = new HttpContext(HttpContext.Current.Request, response); context.SetSessionStateBehavior(SessionStateBehavior.Required); page.ProcessRequest(context); return response; }
private void ShowDebugInfo(HttpContext context, IHttpHandler handler) { if( s_IntegratedPipeline == false ) { handler.ProcessRequest(context); } else { bool isAfterMapRequestHandler = false; try { context.RemapHandler(handler); } catch( InvalidOperationException ) { // 在IIS7的集成管线模式下,当前阶段 >= MapRequestHandler 时,会引发这个异常 isAfterMapRequestHandler = true; } if( isAfterMapRequestHandler ) handler.ProcessRequest(context); } }
public bool MoveNext () { switch (currentYield) { case 0: break; case 1: goto yield_1; case 2: goto yield_2; case 3: goto yield_3; case 4: goto yield_4; #if NET_2_0 case 5: goto yield_5; #endif case 6: goto yield_6; #if NET_2_0 case 7: goto yield_7; #endif case 8: goto yield_8; case 9: goto yield_9; #if NET_2_0 case 10: goto yield_10; case 11: goto yield_11; #endif case 12: goto yield_12; #if NET_2_0 case 13: goto yield_13; #endif case 14: goto yield_14; case 15: goto yield_15; #if NET_2_0 case 16: goto yield_16; #endif case 17: goto yield_17; #if NET_2_0 case 18: goto yield_18; #endif default: goto yield_19; } if (_this.stop_processing) { //yield return true; current = true; currentYield = 1; return true; } yield_1: yield_2: if (_this.BeginRequest != null) { //foreach (bool stop in RunHooks (BeginRequest)) // yield return stop; if (currentEnumerator == null) { currentYield = 2; currentEnumerator = _this.RunHooks(_this.BeginRequest).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } yield_3: if (_this.AuthenticateRequest != null) { //foreach (bool stop in RunHooks (AuthenticateRequest)) // yield return stop; if (currentEnumerator == null) { currentYield = 3; currentEnumerator = _this.RunHooks(_this.AuthenticateRequest).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } yield_4: if (_this.DefaultAuthentication != null) { //foreach (bool stop in RunHooks (DefaultAuthentication)) // yield return stop; if (currentEnumerator == null) { currentYield = 4; currentEnumerator = _this.RunHooks(_this.DefaultAuthentication).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #if NET_2_0 yield_5: if (_this.PostAuthenticateRequest != null) { //foreach (bool stop in RunHooks (AuthenticateRequest)) // yield return stop; if (currentEnumerator == null) { currentYield = 5; currentEnumerator = _this.RunHooks(_this.PostAuthenticateRequest).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #endif yield_6: if (_this.AuthorizeRequest != null) { //foreach (bool stop in RunHooks (AuthorizeRequest)) // yield return stop; if (currentEnumerator == null) { currentYield = 6; currentEnumerator = _this.RunHooks(_this.AuthorizeRequest).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #if NET_2_0 yield_7: if (_this.PostAuthorizeRequest != null) { //foreach (bool stop in RunHooks (PostAuthorizeRequest)) // yield return stop; if (currentEnumerator == null) { currentYield = 7; currentEnumerator = _this.RunHooks(_this.PostAuthorizeRequest).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #endif yield_8: if (_this.ResolveRequestCache != null) { //foreach (bool stop in RunHooks (ResolveRequestCache)) // yield return stop; if (currentEnumerator == null) { currentYield = 8; currentEnumerator = _this.RunHooks(_this.ResolveRequestCache).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } // Obtain the handler for the request. //IHttpHandler handler = null; try { handler = _this.GetHandler (_this.context); } catch (FileNotFoundException fnf){ if (_this.context.Request.IsLocal) _this.ProcessError (new HttpException (404, String.Format ("File not found {0}", fnf.FileName), fnf)); else _this.ProcessError (new HttpException (404, "File not found", fnf)); } catch (DirectoryNotFoundException dnf){ _this.ProcessError (new HttpException (404, "Directory not found", dnf)); } catch (Exception e) { _this.ProcessError (e); } if (_this.stop_processing) { //yield return true; current = true; currentYield = 9; return true; } yield_9: #if NET_2_0 yield_10: if (_this.PostResolveRequestCache != null) { //foreach (bool stop in RunHooks (PostResolveRequestCache)) // yield return stop; if (currentEnumerator == null) { currentYield = 10; currentEnumerator = _this.RunHooks(_this.PostResolveRequestCache).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } yield_11: if (_this.PostMapRequestHandler != null) { //foreach (bool stop in RunHooks (PostMapRequestHandler)) // yield return stop; if (currentEnumerator == null) { currentYield = 11; currentEnumerator = _this.RunHooks(_this.PostMapRequestHandler).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #endif yield_12: if (_this.AcquireRequestState != null){ //foreach (bool stop in RunHooks (AcquireRequestState)) // yield return stop; if (currentEnumerator == null) { currentYield = 12; currentEnumerator = _this.RunHooks(_this.AcquireRequestState).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #if NET_2_0 yield_13: if (_this.PostAcquireRequestState != null){ //foreach (bool stop in RunHooks (PostAcquireRequestState)) // yield return stop; if (currentEnumerator == null) { currentYield = 13; currentEnumerator = _this.RunHooks(_this.PostAcquireRequestState).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #endif // // From this point on, we need to ensure that we call // ReleaseRequestState, so the code below jumps to // `release:' to guarantee it rather than yielding. // if (_this.PreRequestHandlerExecute != null) foreach (bool stop in _this.RunHooks (_this.PreRequestHandlerExecute)) if (stop) goto release; try { _this.context.BeginTimeoutPossible (); if (handler != null){ IHttpAsyncHandler async_handler = handler as IHttpAsyncHandler; if (async_handler != null){ _this.must_yield = true; _this.in_begin = true; async_handler.BeginProcessRequest (_this.context, new AsyncCallback(_this.async_handler_complete_cb), handler); } else { _this.must_yield = false; handler.ProcessRequest (_this.context); } } } catch (ThreadAbortException taex){ object obj = taex.ExceptionState; Thread.ResetAbort (); _this.stop_processing = true; if (obj is StepTimeout) _this.ProcessError (new HttpException ("The request timed out.")); } catch (Exception e){ _this.ProcessError (e); } finally { _this.in_begin = false; _this.context.EndTimeoutPossible (); } if (_this.must_yield) { //yield return stop_processing; current = _this.stop_processing; currentYield = 14; return true; } else if (_this.stop_processing) goto release; yield_14: // These are executed after the application has returned if (_this.PostRequestHandlerExecute != null) foreach (bool stop in _this.RunHooks (_this.PostRequestHandlerExecute)) if (stop) goto release; release: if (_this.ReleaseRequestState != null){ foreach (bool stop in _this.RunHooks (_this.ReleaseRequestState)){ // // Ignore the stop signal while release the state // } } if (_this.stop_processing) { //yield return true; current = true; currentYield = 15; return true; } yield_15: #if NET_2_0 yield_16: if (_this.PostReleaseRequestState != null) { //foreach (bool stop in RunHooks (PostReleaseRequestState)) // yield return stop; if (currentEnumerator == null) { currentYield = 16; currentEnumerator = _this.RunHooks(_this.PostReleaseRequestState).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #endif if (_this.context.Error == null) _this.context.Response.DoFilter (true); yield_17: if (_this.UpdateRequestCache != null) { //foreach (bool stop in RunHooks (UpdateRequestCache)) // yield return stop; if (currentEnumerator == null) { currentYield = 17; currentEnumerator = _this.RunHooks(_this.UpdateRequestCache).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #if NET_2_0 yield_18: if (_this.PostUpdateRequestCache != null) { //foreach (bool stop in RunHooks (PostUpdateRequestCache)) // yield return stop; if (currentEnumerator == null) { currentYield = 18; currentEnumerator = _this.RunHooks(_this.PostUpdateRequestCache).GetEnumerator(); } while (currentEnumerator.MoveNext()) return true; ResetEnumerator(); } #endif _this.PipelineDone (); currentYield = 19; yield_19: return false; }