VS - ActionFilterAttribute

Global.asax.cs

   public class MvcApplication : System.Web.HttpApplication
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            //filters.Add(new HandleErrorAttribute());
            
        }


        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            AuthConfig.RegisterAuth();
            //AntiForgeryConfig.SuppressIdentityHeuristicChecks = true; 
            EPSEmailInfoBLL.RefreshEmailSettings();


            UnityHelper.UnityContainer.LoadConfiguration();
            WebHelper.WebHelperImpl = UnityHelper.Resolve<IWebHelper>(); 
        }
}

 FilterConfig.cs

    public class FilterConfig
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());
            filters.Add(new LogAction() { });
        }
    }

 LogAction.cs

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class LogAction : ActionFilterAttribute
    {

        private string actionName = string.Empty;
        private Stopwatch sw = null;
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            sw = Stopwatch.StartNew();
            actionName = filterContext.ActionDescriptor.ActionName;
            string function = actionName + " Start...";
            if (filterContext.ActionParameters.Count == 0)
            {
                LogFormatHelper.LogRequestParams(function);
            }
            else
            {
                object[] objs = new object[filterContext.ActionParameters.Count];
                int i = 0;
                foreach( var dic in filterContext.ActionParameters){
                    objs[i++] = dic.Value;
                }
                LogFormatHelper.LogRequestParams(function, objs);
            }
            base.OnActionExecuting(filterContext);
        }


        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            base.OnResultExecuted(filterContext);
            string function = actionName + " End";
            StringBuilder sb = new StringBuilder();
            foreach (var key in filterContext.RouteData.Values.Keys)
            {
                sb.AppendFormat("{0} = {1}", key, filterContext.RouteData.Values[key]).AppendLine();
            }
            string str = filterContext.RouteData.Values.ToString();
            LogFormatHelper.LogRequestParams(function, sw.Elapsed , sb.ToString() );

            if (filterContext.Exception != null)
            {
                LogFormatHelper.LogServiceError(filterContext.Exception, actionName);
            }
            
        }

    }

 CheckLoginAttribute.cs

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class CheckLogin : ActionFilterAttribute
    {
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            if (filterContext.HttpContext.Session != null)
            {
                if (filterContext.HttpContext.Session.IsNewSession)
                {
                    //LogFormatHelper.LogRequestParams("filterContext.HttpContext.Session.IsNewSession");
                    filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary(new { Controller = "Account", Action = "Login" }));
                }
            }
        }

    }

 AccountController.cs

    [RequireHttps]
#endif
    [Authorize]
    [InitializeSimpleMembership]
    [LogAction]
    public class AccountController : Controller
    {
        public AccountController()
            : this(new FormsAuthenticationService(), new UserAuthenticator())
        {
            //this.FormsAuth = new FormsAuthenticationService();
        }
}

 NoResubmitAttribute.cs

    [AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
    public class NoResubmitAttribute : ActionFilterAttribute
    {
        private static readonly string HttpMehotdPost = "POST";
        private static readonly string prefix = "postFlag";
        private string nameWithRoute;

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            var controllerContext = filterContext.Controller.ControllerContext;
            if (!controllerContext.IsChildAction)
            {
                var request = controllerContext.HttpContext.Request;
                var session = controllerContext.HttpContext.Session;
                nameWithRoute = generateNameWithRoute(controllerContext);
                int sessionFlag = session[nameWithRoute] == null ? 0 : (int)session[nameWithRoute];
                int requestFlag = string.IsNullOrEmpty(request.Form[nameWithRoute]) ? 0 : int.Parse(request.Form[nameWithRoute]);
                // get or normal post: true;    
                bool isValid = !IsPost(filterContext) || sessionFlag == requestFlag;
                if (sessionFlag == int.MaxValue)
                {
                    sessionFlag = -1;
                }
                session[nameWithRoute] = ++sessionFlag;
                if (!isValid)
                {
                    filterContext.Result = new RedirectResult(GenerateUrlWithTimeStamp(request.RawUrl));
                    return;
                }
            }
            base.OnActionExecuting(filterContext);
        }

        /// <summary>
        /// Modify the url to avoid issue:
        /// When Redirect to itself in a F5 Refresh, the redirect doesn't work in client browser sometimes.
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        private string GenerateUrlWithTimeStamp(string url)
        {
            return string.Format("{0}{1}timeStamp={2}", url, url.Contains("?") ? "&" : "?", (DateTime.Now - DateTime.Parse("2010/01/01")).Ticks);
        }

        private bool IsPost(ActionExecutingContext filterContext)
        {
            return filterContext.HttpContext.Request.HttpMethod == HttpMehotdPost;
        }

        private string generateNameWithRoute(ControllerContext controllerContext)
        {
            StringBuilder sb = new StringBuilder(prefix);
            foreach (object routeValue in controllerContext.RouteData.Values.Values)
            {
                sb.AppendFormat("_{0}", routeValue);
            }
            return sb.ToString();
        }

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

            if (!filterContext.IsChildAction && !(filterContext.Result is RedirectResult))
            {
                //string format = "<script type='text/javascript'>$(function () [[ $('form').each(function()[[$('<input type=hidden id={0} name={0} value={1} />').appendTo($(this));]])]]); </script>";
                string format = "<script type='text/javascript'> var forms = document.getElementsByTagName('form'); for(var i = 0; i<forms.length; i++)[[var ele = document.createElement('input'); ele.type='hidden'; ele.id=ele.name='{0}'; ele.value='{1}'; forms[i].appendChild(ele);]] </script>";
                string script = string.Format(format, nameWithRoute, filterContext.HttpContext.Session[nameWithRoute]).Replace("[[", "{").Replace("]]", "}");
                filterContext.HttpContext.Response.Write(script);
            }
        }
    }

 [ValidateAntiForgeryToken]

EmailAttribute.cs

 

 public class EmailAttribute : RegularExpressionAttribute
    {
        public EmailAttribute()
            : base("[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?")
        {
            ErrorMessage = "The field {0} is an invalid email address.";
        }
    }