C# IContext.Clear方法代码示例

        /// <summary>
        /// Obtains and processes the chain of controllers servicing this request. If a transfer is requested
        /// during the processing of a controller, the computed chain of controllers finishes, and then a
        /// recursive call is made to process the new contrller.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="requestPoint">The request point.</param>
        /// <param name="requestContext">The request context.</param>
        public virtual void InvokeMethod(HttpContextBase context, string requestPoint, IContext requestContext)
        {
            logger.Report(Messages.ProcessingRequest, requestPoint);

            try
            {
                InvokeMethodDirect(context, requestPoint, requestContext);
            }
            catch (Exception ex)
            {
                if (!IsMethodDefinedExplicitly(Application.UnhandledException))
                    throw;

                requestContext.Clear();
                requestContext.Add("unhandledException", ex);

                InvokeMethodDirect(context, Application.UnhandledException, requestContext);
            }
        }

        /// <summary>
        /// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler"/> interface.
        /// </summary>
        /// <param name="context">An <see cref="T:System.Web.HttpContext"/> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>
        /// <summary>
        /// Obtains and processes the chain of controllers servicing this request. If a transfer is requested
        /// during the processing of a controller, the computed chain of controllers finishes, and then a
        /// recursive call is made to process the new contrller.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="requestPoint">The request point.</param>
        /// <param name="requestContext">The request context.</param>
        public virtual void InvokeMethod(HttpContextBase context, string requestPoint, IContext requestContext, bool handleException)
        {
            logger.Report(Messages.ProcessingRequest, requestPoint);

            try
            {
				List<ControllerInvocationInfo> invocationInfos = dispatcher.GetControllers(requestPoint);

				// TODO: this code should be replaced with call to the check method 
				// when it will be implemented on the dispatcher correctly
                if (invocationInfos.Count() == 0)
                {
                    logger.Report(Messages.ControllerNotFound, requestPoint);
                    throw new WebException(StatusCode.NotFound, String.Format("'{0} could not be found", requestPoint));
                }

				StringBuilder path = new StringBuilder();
				foreach (ControllerInvocationInfo info in invocationInfos)
					path.Append(info.BindPoint.Controller.ControllerTypeName).Append(" based on ").Append(info.BindPoint.Target).Append("\r\n");

				logger.Report(Messages.ExecutionPath, requestPoint, path.ToString());


				bool securityCheckComplete = false;
				bool securityCheckFailed = false;
				var failedPermissions = new Dictionary<string, KeyValuePair<FailAction, string>>();

				Stopwatch sw = new Stopwatch();
				Stopwatch sw1 = new Stopwatch();

				foreach (ControllerInvocationInfo invocationInfo in invocationInfos)
                {
					sw.Reset();
					sw.Start(); 
					
					
					IController controller = manager.GetController(invocationInfo, context, requestContext);

					try
					{
						// all security controllers are guaranteed to be at the top of the list, in proper order.
						// we need to run through all of them, because an inner controller may override the decision 
						// of an outer controller. therefore, the final decision is deferred until all security checks
						// have passed
						if (!securityCheckComplete)
						{
							ISecurityController securityController = controller as ISecurityController;
							if (securityController == null)
								securityCheckComplete = true;
							else
							{
								// this needs to run prior to the check
								controller.ProcessRequest(context, requestContext);

								// we only care about the actual return value of the last controller, as intermediate
								// results can be overriden by subsequent controllers. discard intermediate return values.
								securityCheckFailed = !securityController.HasAccess(requestContext, failedPermissions);
							}
						}

						// we have to do the check a second time, because the securityCheckComplete flag
						// gets set inside the top if. doing this in an else up top would skip the first
						// non-security controller
						if (securityCheckComplete)
						{
							if (securityCheckFailed || failedPermissions.Count != 0)
							{
								StringBuilder builder = new StringBuilder();
								foreach (string perm in failedPermissions.Keys)
									builder.AppendLine(perm);

								foreach (KeyValuePair<FailAction, string> kvp in failedPermissions.Values)
									if (kvp.Key == FailAction.Redirect)
									{
										// currently you can only house one transfer request per context, 
										// however, that may change in the future.
										requestContext.ClearTransferRequest();

										// give the fail action target a chance to redirect after re-validating
										requestContext.Transfer(
											kvp.Value +
											(kvp.Value.Contains("?") ? "&" : "?") +
											"originalRequest=" +
											HttpUtility.UrlEncode(requestPoint));

										logger.Report(Messages.SecurityRedirect, kvp.Value, builder.ToString());
										break;
									}
//.........这里部分代码省略.........