public override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     MonitorLog MonLog = filterContext.Controller.ViewData[Key] as MonitorLog;
     MonLog.ExecuteEndTime = DateTime.Now;
     LoggerHelper.Monitor(MonLog.GetLoginfo(MonitorLog.MonitorType.View));
     filterContext.Controller.ViewData.Remove(Key);
 }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            //We might want to close sessions even if we aren't delegated transaction support
            if (_delegateTransactionSupport) return;

            _dbContext.CloseSession();
        }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            string effectiveFactoryKey = GetEffectiveFactoryKey();

            ITransaction currentTransaction =
                NHibernateSession.CurrentFor(effectiveFactoryKey).Transaction;

            base.OnResultExecuted(filterContext);
            try
            {
                if (currentTransaction.IsActive) {
                    if ((filterContext.Exception != null) && (!filterContext.ExceptionHandled))
                    {
                        currentTransaction.Rollback();
                    }
                    else
                    {
                        currentTransaction.Commit();
                    }
                }
            }
            finally
            {
                currentTransaction.Dispose();
            }
        }

 /// <summary>
 /// Ensures that the controller is of the required type, if so lets execution continue on the base class
 /// </summary>
 /// <param name="filterContext"></param>
 public override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     var backOfficeController = GetController(filterContext.Controller);
     if (!backOfficeController.Notifications.Any())
         return;
     base.OnResultExecuted(filterContext);
 }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            base.OnResultExecuted(filterContext);
            #if Page_Trace
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            #endif
            if (Page_Context.Current.PageRequestContext != null)
            {

                var site = Page_Context.Current.PageRequestContext.Site;
                var page = Page_Context.Current.PageRequestContext.Page.AsActual();

                var outputTextWriterWrapper = filterContext.HttpContext.Response.Output as OutputTextWriterWrapper;
                if (outputTextWriterWrapper != null
                    && !(filterContext.Result is CachedContentResult)
                    && filterContext.Exception == null
                    && filterContext.HttpContext.Response.ContentType.ToLower().Contains("text/html"))
                {
                    var html = outputTextWriterWrapper.ToString();
                    var htmlParser = Kooboo.CMS.Common.Runtime.EngineContext.Current.TryResolve<IHtmlParser>();
                    if (htmlParser != null)
                    {
                        html = htmlParser.Parse(html);
                        outputTextWriterWrapper.Flush();
                        outputTextWriterWrapper.Write(html);
                    }
                }
            }

            #if Page_Trace
            stopwatch.Stop();
            filterContext.HttpContext.Response.Write(string.Format("PageHtmlParserActionFilter.OnResultExecuted, {0}ms.</br>", stopwatch.ElapsedMilliseconds));
            #endif
        }

		public void Should_delegate_to_result_filter_executed()
		{
			var attribute = new FilterUsingAttribute(typeof(TestResultFilter));
			var context = new ResultExecutedContext();
			attribute.OnResultExecuted(context);
			context.Result.ShouldBe<EmptyResult>();
		}

        protected override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            if (_resultExecutingToExecuted != null)
                _resultExecutingToExecuted.Dispose();

            base.OnResultExecuted(filterContext);
        }

        /// <summary>
        /// Called by the ASP.NET MVC framework after the action result executes.
        /// </summary>
        /// <param name="filterContext">The filter context.</param>
        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            base.OnResultExecuted(filterContext);

            AdminBaseController.CurrentEnvironment = null;
            AdminBaseController.CurrentController = null;
        }

 public override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     string contentType = filterContext.HttpContext.Response.ContentType;
     if (contentType == "application/json")
         filterContext.HttpContext.Response.ContentType = "text/html";
     base.OnResultExecuted(filterContext);
 }

 protected override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     timer.Stop();
     filterContext.HttpContext.Response.Write(
         string.Format("<div>Total elapsed time: {0}</div>",
         timer.Elapsed.TotalSeconds));
 }

 public override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     timer.Stop();
     filterContext.HttpContext.Response.Write(
         string.Format("Action result elapsed time: {0}",
             timer.Elapsed.TotalSeconds));
 }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            base.OnResultExecuted(filterContext);

            if (!IsEnable)
                return;

            if (filterContext.IsChildAction)
                return;

            if (filterContext.Exception != null || filterContext.HttpContext.Error != null)
                return;

            HttpRequestBase request = filterContext.HttpContext.Request;
            string acceptEncoding = request.Headers["Accept-Encoding"];
            if (string.IsNullOrEmpty(acceptEncoding))
                return;

            acceptEncoding = acceptEncoding.ToUpperInvariant();
            HttpResponseBase response = filterContext.HttpContext.Response;

            //if (response.IsRequestBeingRedirected)
            //    return;

            if (acceptEncoding.Contains("GZIP"))
            {
                response.AppendHeader("Content-encoding", "gzip");
                response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
            }
            else if (acceptEncoding.Contains("DEFLATE"))
            {
                response.AppendHeader("Content-encoding", "deflate");
                response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
            }
        }

        public override void OnResultExecuted(ResultExecutedContext context)
        {
            var resultType = context.Result.GetType().Name;
            LogManager.GetLogger("").Info("ResultExecuted: " + context.Controller + " ⇒ " + resultType);

            base.OnResultExecuted(context);
        }

        public void OnResultExecuted(ResultExecutedContext filterContext)
        {
            foreach (var sitePart in _orchardServices.WorkContext.CurrentSite.ContentItem.Parts)
            {
                foreach (var property in sitePart.GetType().GetProperties().Where(p=>p.Name!="Id"))//id will always be 1 because this part is bound to the site
                {
                    try {
                        var propertyType = property.PropertyType;
                        // Supported types (we also know they are not indexed properties).
                        if ((propertyType == typeof (string) || propertyType == typeof (bool) || propertyType == typeof (int))
                            && property.CanRead) {
                            var value = property.GetValue(sitePart, null);

                            _performanceMonitor.PublishMessage(new SiteSettingsMessage {
                                Part = sitePart.PartDefinition.Name,
                                Name = property.Name,
                                Value = value
                            });
                        }
                    }
                    catch (Exception ex) {
                        //todo: figure out why this occaisionally fails
                    }
                }
            }
        }

 public override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     base.OnResultExecuted(filterContext);
     if (Page_Context.Current.PageRequestContext != null)
     {
         var site = Page_Context.Current.PageRequestContext.Site;
         var page = Page_Context.Current.PageRequestContext.Page.AsActual();
         if (!filterContext.HttpContext.Request.IsAjaxRequest() && !filterContext.HttpContext.User.Identity.IsAuthenticated && page.CacheToDisk)
         {
             var outputTextWriterWrapper = filterContext.HttpContext.Response.Output as OutputTextWriterWrapper;
             if (outputTextWriterWrapper != null
                 && filterContext.Exception == null
                 && filterContext.HttpContext.Response.ContentType.ToLower().Contains("text/html"))
             {
                 try
                 {
                     var html = outputTextWriterWrapper.ToString();
                     PageCachingManager.AddCaching(filterContext.HttpContext, page, html);
                 }
                 catch (Exception e)
                 {
                     Kooboo.HealthMonitoring.Log.LogException(e);
                 }
             }
         }
     }
 }

 public static void Reset()
 {
     LastRequestData.ActionExecutedContext = null;
     LastRequestData.ResultExecutedContext = null;
     LastRequestData.HttpSessionState = null;
     LastRequestData.Response = null;
 }

 public override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     if (filterContext.Exception != null)
     {
         filterContext.HttpContext.Response.Filter = null;
     }
 }

 public override void OnResultExecuted(ResultExecutedContext filterContext)
 {
     base.OnResultExecuted(filterContext);
     var infoObject = (InfoObject)filterContext.RequestContext.HttpContext.Request.RequestContext.RouteData.DataTokens[profile];
     infoObject.ResultExecuted = (int)((Stopwatch)filterContext.RequestContext.HttpContext.Request.RequestContext.RouteData.DataTokens[stopwatch]).ElapsedMilliseconds;
     _bag.Add(infoObject);
 }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            var controller = filterContext.Controller as SessionController;
            if( controller==null )
            {
                return;
            }

            using(var session = controller.Session)
            {
                if( session==null )
                {
                    return;
                }

                using(var transaction = session.Transaction)
                {
                    if( transaction==null || !transaction.IsActive )
                    {
                        return;
                    }

                    if( filterContext.Exception!=null )
                    {
                        transaction.Rollback();
                    }
                    else
                    {
                        transaction.Commit();
                    }
                    transaction.Dispose();
                }
            }
        }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            base.OnResultExecuted(filterContext);
#if Page_Trace
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
#endif
            if (Page_Context.Current.PageRequestContext != null)
            {

                var site = Page_Context.Current.PageRequestContext.Site;
                var page = Page_Context.Current.PageRequestContext.Page.AsActual();
                if (!filterContext.HttpContext.User.Identity.IsAuthenticated && page.EnabledCache)
                {
                    var outputTextWriterWrapper = filterContext.HttpContext.Response.Output as OutputTextWriterWrapper;
                    if (outputTextWriterWrapper != null
                        && filterContext.Exception == null
                        && filterContext.HttpContext.Response.ContentType.ToLower().Contains("text/html"))
                    {
                        var cacheKey = GetOutputCacheKey(filterContext.HttpContext, page);
                        if (outputTextWriterWrapper != null && site.ObjectCache().Get(cacheKey) == null)
                        {
                            site.ObjectCache().Add(cacheKey, outputTextWriterWrapper.ToString(), page.AsActual().OutputCache.ToCachePolicy());
                        }
                    }
                }

            }

#if Page_Trace
            stopwatch.Stop();
            filterContext.HttpContext.Response.Write(string.Format("OutputCacheFilterAttribute.OnResultExecuted, {0}ms.</br>", stopwatch.ElapsedMilliseconds));
#endif
        }