C# Mvc.ControllerBase类代码示例

        public static void ToPaging(int pageIndex, int dataCount, ControllerBase controller, int pageSize = 20)
        {
            int pagesCount = 1;
            int pageStartIndex = 1;
            int pageEndIndex = 0;
            controller.ViewBag.PageNowIndex = pageIndex;
            controller.ViewBag.PageSize = pageSize;
            controller.ViewBag.PagesCount = pagesCount = pageEndIndex = int.Parse(Math.Ceiling((double)dataCount / pageSize).ToString());

            if (pagesCount > 9)
            {
                //最多显示9个页码
                if (pageIndex > 5)
                {
                    pageStartIndex = pageIndex - 4;
                    if (pagesCount - pageIndex > 4)
                        pageEndIndex = pageIndex + 4;
                }
                else
                    pageEndIndex = 9;
            }

            controller.ViewBag.PageStartIndex = pageStartIndex;
            controller.ViewBag.PageEndIndex = pageEndIndex;
        }

        protected virtual ActionResult Dynamic(ControllerBase controller, string viewName, object model, Func<ControllerBase, Dictionary<string, object>, string, object, object> json)
        {
            var propertyBag = new Dictionary<string, object>();
            
            if (model != null)
            {
                List<JsonField> properties;
                var cacheKey = model.GetType().FullName;

                if (!_propertyCache.TryGet(cacheKey, out properties))
                {
                    properties = new List<JsonField>();
                    properties.AddRange(model.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)
                        .Where(property => GetCustomAttribute(property, typeof(JsonPropertyAttribute)) != null)
                        .Select(property => new JsonField(property, (JsonPropertyAttribute)GetCustomAttribute(property, typeof(JsonPropertyAttribute))))
                        .ToList());
                    properties.AddRange(model.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)
                        .Where(field => GetCustomAttribute(field, typeof(JsonPropertyAttribute)) != null)
                        .Select(field => new JsonField(field, (JsonPropertyAttribute)GetCustomAttribute(field, typeof(JsonPropertyAttribute))))
                        .ToList());

                    _propertyCache.Add(cacheKey, properties);
                }

                properties.ForEach(property => propertyBag.Add(property.Name, property.GetValue(model)));
            }

            return controller.AsDynamic().Json(json(controller, propertyBag, viewName, model), JsonRequestBehavior.AllowGet);
        }

        private static void WriteForgeryToken(ControllerBase controller)
        {
            string cookieToken, formToken;
            var context = controller.ControllerContext.HttpContext;

            var oldCookie = context.Request.Cookies[AntiForgeryConfig.CookieName];
            var oldCookieToken = oldCookie != null ? oldCookie.Value : null;

            AntiForgery.GetTokens(oldCookieToken, out cookieToken, out formToken);
            context.Items[FlushedAntiForgeryTokenKey] = formToken;

            if (AntiForgeryConfig.RequireSsl && !context.Request.IsSecureConnection)
            {
                throw new InvalidOperationException("WebPageResources.AntiForgeryWorker_RequireSSL");
                    //TODO: Find string message
            }

            var response = context.Response;

            if (!string.IsNullOrEmpty(cookieToken))
            {
                response.Cookies.Set(new HttpCookie(AntiForgeryConfig.CookieName, cookieToken) { HttpOnly = true });
            }

            if (!AntiForgeryConfig.SuppressXFrameOptionsHeader)
            {
                // Adding X-Frame-Options header to prevent ClickJacking. See
                // http://tools.ietf.org/html/draft-ietf-websec-x-frame-options-10
                // for more information.
                response.AddHeader("X-Frame-Options", "SAMEORIGIN");
            }
        }

 private static ModelValidator GetModelValidator(this object model, ControllerBase controller)
 {
     return ModelValidator.GetModelValidator(
         ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
         controller.ControllerContext
         );
 }

 private static ActionDescriptor GetActionDescriptor(ControllerBase controller, RouteData routeData)
 {
     var controllerDescriptor = new ReflectedControllerDescriptor(controller.GetType());
     var actionName = routeData.GetRequiredString("action");
     var actionDescriptor = controllerDescriptor.FindAction(controller.ControllerContext, actionName);
     return actionDescriptor;
 }

        /// <summary>
        /// Get the label with the specified key from the resource files.
        /// </summary>
        /// <param name="controller">Controller that requests the resource.</param>
        /// <param name="key">The key.</param>
        /// <param name="fallbackToKey">If true then if a resource is not found with the specified key the key is returned.</param>
        private static string Resource(ControllerBase controller, RouteData routeData, string key, bool fallbackToKey)
        {
            var resClass = LocalizationHelpers.FindResourceStringClassType(controller.GetType());

            var widgetName = routeData != null ? routeData.Values["widgetName"] as string : null;
            if (!string.IsNullOrEmpty(widgetName))
            {
                var widget = FrontendManager.ControllerFactory.ResolveControllerType(widgetName);
                if (widget != null)
                {
                    var widgetResClass = LocalizationHelpers.FindResourceStringClassType(widget);
                    string res;
                    if (widgetResClass != null && Res.TryGet(widgetResClass.Name, key, out res))
                    {
                        return res;
                    }
                }
            }

            string result;
            if (Res.TryGet(resClass.Name, key, out result))
            {
                return result;
            }

            if (fallbackToKey)
            {
                return key;
            }
            
            return "#ResourceNotFound: {0}, {1}#".Arrange(resClass.Name, key);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="TaxonomyUrlParamsMapper" /> class.
 /// </summary>
 /// <param name="controller">The controller.</param>
 /// <param name="taxonUrlEvaluator">The taxon URL evaluator.</param>
 /// <param name="actionName">Name of the action.</param>
 public TaxonomyUrlParamsMapper(ControllerBase controller, TaxonUrlMapper taxonUrlEvaluator, string actionName = TaxonomyUrlParamsMapper.DefaultActionName)
     : base(controller)
 {
     this.actionName = actionName;
     this.taxonUrlEvaluator = taxonUrlEvaluator;
     this.actionMethod = controller.GetType().GetMethod(this.actionName, BindingFlags.Instance | BindingFlags.Public);
 }

 public static ControllerContext CreateMockControllerContext(ControllerBase controller)
 {
     var mockHttpContext = CreateMockHttpContext();
       var controllerContext = new ControllerContext(mockHttpContext, new RouteData(), controller);
       controller.ControllerContext = controllerContext;
       return controllerContext;
 }

        /// <summary>
        /// Sets the alert for the mvc view to render. Rendered by Html.RenderAlertMessages().
        /// </summary>
        /// <param name="controllerBase">The MVC controller from which this call is being made.</param>
        /// <param name="alert">The populated alert to show to the user.</param>
        /// <exception cref="ArgumentNullException">If either argument is null.</exception>
        public static void AppendAlert(ControllerBase controllerBase, AlertDetail alert)
        {
            if (controllerBase == null)
                throw new ArgumentNullException("controllerBase");
            if (alert == null)
                throw new ArgumentNullException("alert");

            Queue<AlertDetail> queue;

            // Get the queue
            if (alert.EnableCrossView)
                queue = controllerBase.TempData["CouncilSoft.BootstrapAlerts"] as Queue<AlertDetail>;
            else
                queue = controllerBase.ViewData["CouncilSoft.BootstrapAlerts"] as Queue<AlertDetail>;

            // Or create the queue
            if (queue == null)
                queue = new Queue<AlertDetail>();

            // Enqueue the item
            queue.Enqueue(alert);

            // Persist the updated queue.
            if (alert.EnableCrossView)
                controllerBase.TempData["CouncilSoft.BootstrapAlerts"] = queue;
            else
                controllerBase.ViewData["CouncilSoft.BootstrapAlerts"] = queue;
        }

        /// <summary>
        /// Ensure TempData and ViewData is copied across
        /// </summary>
        private static void CopyControllerData(ControllerContext context, ControllerBase controller)
        {
            foreach (var d in context.Controller.ViewData)
                controller.ViewData[d.Key] = d.Value;

            controller.TempData = context.Controller.TempData;
        }

        public void Hydrate(ControllerBase controller)
        {
            if (_model == null)
                return;

            controller.ViewData.Model = _model;
        }

		public static ControllerContext CreateControllerContext (ControllerBase controller, Dictionary<string, string> formValues, 
									 HttpCookieCollection requestCookies, IDictionary<string, string> routeData)
		{
			HttpContextBase httpContext = CreateHttpContext ();

			if (formValues != null) {
				foreach (string key in formValues.Keys)
					httpContext.Request.Form.Add (key, formValues[key]);
			}

			if (requestCookies != null) {
				foreach (string key in requestCookies.Keys)
					httpContext.Request.Cookies.Add (requestCookies[key]);
			}

			RouteData route = new RouteData ();
			route.Values.Add ("controller", controller.GetType ().Name);

			if (routeData != null) {
				foreach (var valuePair in routeData)
					route.Values.Add (valuePair.Key, valuePair.Value);
			}

			return new ControllerContext (new RequestContext (httpContext, route), controller);
		}

 public FakeControllerContext(
     ControllerBase controller,
     IPrincipal principal
     )
     : base(new FakeHttpContext(principal, null, null, null, null), new RouteData(), controller)
 {
 }

 private static IDictionary<string, MvcHtmlString> GetFlashMessages(ControllerBase controller, string sessionKey)
 {
     sessionKey = "Flash." + sessionKey;
     return (controller.TempData[sessionKey] != null
                 ? (IDictionary<string, MvcHtmlString>)controller.TempData[sessionKey]
                 : new Dictionary<string, MvcHtmlString>());
 }

 private static void EnsureControllerContext(ControllerBase controller)
 {
     if (controller.ControllerContext==null)
     {
         controller.ControllerContext=new ControllerContext();
     }
 }