Wie gedrosselt Anfragen in einem Web API?

Scheinen Sie zu verwirren action-Filter für eine ASP.NET MVC-controller-und action-Filter für eine ASP.NET Web-API-controller. Das sind 2 komplett verschiedene Klassen:

• Für ASP.NET MVC: System.Web.Mvc.ActionFilterAttribute -> das ist das, was ich aus dem link
• Für ASP.NET Web-API: System.Web.Http.Filter.ActionFilterAttribute -> das ist, was Sie implementieren müssen, um

Es scheint, dass das, was Sie gezeigt haben, ist eine Web-API controller-Aktion (eine, die erklärt, innerhalb einer controller-Ableitung von ApiController). Also, wenn Sie wollen, um benutzerdefinierte Filter anwenden, müssen Sie stammen aus System.Web.Http.Filters.ActionFilterAttribute.

Also lassen Sie uns gehen Sie vor und passen Sie den code für die Web-API:

public class ThrottleAttribute : ActionFilterAttribute
{
    ///<summary>
    ///A unique name for this Throttle.
    ///</summary>
    ///<remarks>
    ///We'll be inserting a Cache record based on this name and client IP, e.g. "Name-192.168.0.1"
    ///</remarks>
    public string Name { get; set; }

    ///<summary>
    ///The number of seconds clients must wait before executing this decorated route again.
    ///</summary>
    public int Seconds { get; set; }

    ///<summary>
    ///A text message that will be sent to the client upon throttling.  You can include the token {n} to
    ///show this.Seconds in the message, e.g. "Wait {n} seconds before trying again".
    ///</summary>
    public string Message { get; set; }

    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        var key = string.Concat(Name, "-", GetClientIp(actionContext.Request));
        var allowExecute = false;

        if (HttpRuntime.Cache[key] == null)
        {
            HttpRuntime.Cache.Add(key,
                true, //is this the smallest data we can have?
                null, //no dependencies
                DateTime.Now.AddSeconds(Seconds), //absolute expiration
                Cache.NoSlidingExpiration,
                CacheItemPriority.Low,
                null); //no callback

            allowExecute = true;
        }

        if (!allowExecute)
        {
            if (string.IsNullOrEmpty(Message))
            {
                Message = "You may only perform this action every {n} seconds.";
            }

            actionContext.Response = actionContext.Request.CreateResponse(
                HttpStatusCode.Conflict, 
                Message.Replace("{n}", Seconds.ToString())
            );
        }
    }
}

wo die GetClientIp Methode stammt aus post.

Nun mit diesem Attribut können Sie auf Ihrem Web-API-controller Aktion.

InformationsquelleAutor der Antwort Darin Dimitrov

WebApiThrottle ist ganz der champ jetzt in diesem Bereich.

Es ist super einfach zu integrieren. Fügen Sie einfach den folgenden App_Start\WebApiConfig.cs:

config.MessageHandlers.Add(new ThrottlingHandler()
{
    //Generic rate limit applied to ALL APIs
    Policy = new ThrottlePolicy(perSecond: 1, perMinute: 20, perHour: 200)
    {
        IpThrottling = true,
        ClientThrottling = true,
        EndpointThrottling = true,
        EndpointRules = new Dictionary<string, RateLimits>
        { 
             //Fine tune throttling per specific API here
            { "api/search", new RateLimits { PerSecond = 10, PerMinute = 100, PerHour = 1000 } }
        }
    },
    Repository = new CacheRepository()
});

Es ist als nuget-auch mit dem gleichen Namen.

InformationsquelleAutor der Antwort Korayem

Ich bin mit ThrottleAttribute zur Begrenzung der Berufung rate von meinem kurz-Nachricht senden-API, aber ich fand es nicht funktioniert manchmal. API genannt worden, viele Male, bis die Drosselklappe arbeitet der Logik, schließlich bin ich mit System.Web.Caching.MemoryCache statt HttpRuntime.Cache und das problem scheint gelöst.

if (MemoryCache.Default[key] == null)
{
    MemoryCache.Default.Set(key, true, DateTime.Now.AddSeconds(Seconds));
    allowExecute = true;
}

InformationsquelleAutor der Antwort Bruce