private static void AddEntryToList(HttpVerbs verbs, HttpVerbs match, List<string> verbList, string entryText)
 {
     if ((verbs & match) != 0)
     {
         verbList.Add(entryText);
     }
 }

 /// <summary>
 /// 初始化一个新的<see cref="DynamicApiActionInfo"/>实例
 /// </summary>
 /// <param name="actionName">Action 名称</param>
 /// <param name="verb">HTTP Verb</param>
 /// <param name="method">一个方法信息，随着 Action 的调用而调用</param>
 /// <param name="filters">用于 Controller Action 的动态筛选器</param>
 public DynamicApiActionInfo(string actionName, HttpVerbs verb, MethodInfo method, IFilter[] filters = null)
 {
     ActionName = actionName;
     Verb = verb;
     Method = method;
     Filters = filters ?? new IFilter[] { };
 }

 protected static void CheckForBindingInPutOperations(HttpVerbs requestVerb)
 {
     if (requestVerb == HttpVerbs.PUT)
     {
         throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.BadRequest_CannotUpdateRelatedEntitiesInPut);
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="RESTFulActionConstraint"/> class.
        /// </summary>
        /// <param name="httpVerb">The HTTP verb.</param>
        /// <param name="requiresId">if set to <c>true</c> [requires id].</param>
        public RESTFulActionConstraint(HttpVerbs httpVerb, bool requiresId)
        {
            HttpVerbs = httpVerb;
            RequiresId = requiresId;

            verbs = ConvertToStringList(HttpVerbs);
        }

        public PartialViewResult Users(HttpVerbs? method, int? page, int? sizePage)
        {
            var model = new ModelTestApiResult();

            // if 'Get'
            if(method == HttpVerbs.Get)
            {
                // start the timer
                var timer = Stopwatch.StartNew();

                // perform the call
                List<UserV2> users;
                var response = LicenceManager.TryListUsers(out users);

                // stop the timer
                timer.Stop();
                model.ElapsedMilliseconds = timer.ElapsedMilliseconds;

                // get the content
                model.Users = users;
                // get the code
                model.ResponseBody = response.GetBodyAsString();
                // get the exception message
                model.Message = response.MessageError;
                // get the status code
                model.StatusCode = response.StatusHttp;
            }
                // if method is not supported
            else
                model.Message = "Method not supported";

            return this.PartialView("Result", model);
        }

        private Method GetRestsharpMethod(HttpVerbs method)
        {
            Method result;

            switch (method)
            {
                case HttpVerbs.Get:
                    result = Method.GET;
                    break;
                case HttpVerbs.Post:
                    result = Method.POST;
                    break;
                case HttpVerbs.Put:
                    result = Method.PUT;
                    break;
                case HttpVerbs.Patch:
                    result = Method.PATCH;
                    break;
                case HttpVerbs.Delete:
                    result = Method.DELETE;
                    break;
                case HttpVerbs.Head:
                    result = Method.HEAD;
                    break;
                default:
                    result = Method.GET;
                    break;
            }

            return result;
        }

 private static void RunPostExecutionFilters(IAction action, HttpVerbs httpVerb) {
     var filters = GetFilters(action, httpVerb);
     filters.ForEach(x => {
                         x.Context = action.Context;
                         x.AfterExecute();
                     });
 }

 public ValidateAntiForgeryTokenWrapperAttribute(HttpVerbs verbs)
 {
   this._verbs = new AcceptVerbsAttribute(verbs);
   this._validator = new ValidateAntiForgeryTokenAttribute()
   {
     Salt = Consts.AntiForgeryToken
   };
 }

		public ApiDocumentationAttribute( String url, String description = "", Type returnType = null, HttpVerbs requestType = HttpVerbs.Get, Type formBody = null )
		{
			Url = url;
			Description = description;
			ReturnType = returnType;
			RequestType = requestType;
			FormBody = formBody;
		}		

 /// <summary>
 /// Initializes a new instance of the <see cref="ClientPreference"/> class.
 /// </summary>
 /// <param name="requestDescription">The request description.</param>
 /// <param name="verb">The request verb.</param>
 /// <param name="requestMessage">The request message.</param>
 /// <param name="effectiveMaxResponseVersion">The effective max response version for the request, which is the min of MDSV and MPV.</param>
 public ClientPreference(RequestDescription requestDescription, HttpVerbs verb, IODataRequestMessage requestMessage, Version effectiveMaxResponseVersion)
     : this(InterpretClientPreference(requestDescription, verb, requestMessage))
 {
     if (effectiveMaxResponseVersion >= VersionUtil.Version4Dot0)
     {
         this.annotationFilter = requestMessage.PreferHeader().AnnotationFilter;
     }
 }

 public ValidateAntiForgeryTokenWrapperAttribute(HttpVerbs verbs, string salt)
 {
     this._verbs = new AcceptVerbsAttribute(verbs);
     this._validator = new ValidateAntiForgeryTokenAttribute()
     {
         Salt = salt
     };
 }

        public string DoRequest(string query, HttpVerbs method, Action<Stream> data, string contenttype)
        {

            Stream stream = DoDataRequest(query, method, data, contenttype);
            System.IO.StreamReader sr = new StreamReader(stream, Encoding.UTF8);

            return sr.ReadToEnd();
        }

 public static HtmlTag Form
     (this HtmlHelper html, string actionName, string controllerName, RouteValueDictionary routeValues,
      HttpVerbs method)
 {
     var action = UrlHelper.GenerateUrl
         (null, actionName, controllerName, routeValues, html.RouteCollection,
          html.ViewContext.RequestContext, true);
     return BuildForm(action, method);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="CustomValidateAntiForgeryTokenAttribute"/> class.
        /// </summary>
        /// <param name="verbs">The verbs.</param>
        /// <param name="salt">The salt.</param>
        public CustomValidateAntiForgeryTokenAttribute(HttpVerbs verbs, string salt)
        {
            Verbs = verbs;
            Salt = salt;

            AcceptVerbsAttribute = new AcceptVerbsAttribute(Verbs);
            Validator = new ValidateAntiForgeryTokenAttribute
            {
                Salt = Salt
            };
        }

        internal static string[] EnumToArray(HttpVerbs verbs) {
            List<string> verbList = new List<string>();

            AddEntryToList(verbs, HttpVerbs.Get, verbList, "GET");
            AddEntryToList(verbs, HttpVerbs.Post, verbList, "POST");
            AddEntryToList(verbs, HttpVerbs.Put, verbList, "PUT");
            AddEntryToList(verbs, HttpVerbs.Delete, verbList, "DELETE");
            AddEntryToList(verbs, HttpVerbs.Head, verbList, "HEAD");

            return verbList.ToArray();
        }

 public BaseAuthorizationProvider(HttpContextBase hcb)
 {
     Context = hcb;
     var rdv = ((MvcHandler)Context.CurrentHandler).RequestContext.RouteData.Values;
     Httpverb = (HttpVerbs)(Enum.Parse(typeof(HttpVerbs), Context.Request.GetHttpMethodOverride(), true)); // returns actual method if no override specified.
     // assumes specific Resources will be accessed by Id (see BaseResourceModel)
     // _id = rdv.ContainsKey("Id") ? rdv["Id"].ToString() : "";
     Controller = rdv["controller"].ToString();
     Action = rdv["action"].ToString();
     //var n = _context.User.Identity.Name;
     Init();
 }

 private void Route(string action, HttpVerbs verb)
 {
     var actionName = action.ToLowerInvariant();
     if (!_actions.ContainsKey(action))
         _actions[actionName] = new[] { verb };
     else
     {
         var verbs = _actions[actionName].ToList();
         verbs.Add(verb);
         _actions[actionName] = verbs.ToArray();
     }
 }

        private static ReadOnlyCollection<string> ConvertVerbs(HttpVerbs verbs)
        {
            ReadOnlyCollection<string> verbsAsCollection;
            if (_verbsToVerbCollections.TryGetValue(verbs, out verbsAsCollection))
            {
                return verbsAsCollection;
            }

            verbsAsCollection = new ReadOnlyCollection<string>(EnumToArray(verbs));
            _verbsToVerbCollections.TryAdd(verbs, verbsAsCollection);
            return verbsAsCollection;
        }

        public static RouteData For(this RouteCollection routes, HttpVerbs verb, string url)
        {
            var httpContext = MockRepository.GenerateStub<HttpContextBase>();
            var httpRequest = MockRepository.GenerateStub<HttpRequestBase>();
            httpContext.Stub(x => x.Request).Return(httpRequest);

            httpRequest.Stub(r => r.Headers).Return(new NameValueCollection());
            httpRequest.Stub(r => r.PathInfo).Return(string.Empty);
            httpRequest.Stub(r => r.AppRelativeCurrentExecutionFilePath).Return(url);
            httpRequest.Stub(r => r.HttpMethod).Return(Enum.GetName(typeof(HttpVerbs), verb));

            return routes.GetRouteData(httpContext);
        }

 private void Route(string resource, string action, HttpVerbs verb)
 {
     var actionName = RouteSet.LowercaseActions ? action.ToLowerInvariant() : action;
     if (!_actions.ContainsKey(action))
         _actions[actionName] = new KeyValuePair<string,HttpVerbs[]>(resource, new[] { verb });
     else
     {
         var keyValue = _actions[actionName];
         var verbs = keyValue.Value.ToList();
         verbs.Add(verb);
         _actions[actionName] = new KeyValuePair<string,HttpVerbs[]>(keyValue.Key, verbs.ToArray());
     }
 }