Comment faire pour limiter les demandes dans les Api Web?

Vous semblez être source de confusion action des filtres pour une ASP.NET MVC contrôleur et l'action des filtres pour une ASP.NET Web API contrôleur. Ceux sont 2 des classes complètement différentes:

• Pour ASP.NET MVC: System.Web.Mvc.ActionFilterAttribute -> c'est ce que vous avez obtenu à partir du lien
• Pour ASP.NET l'API Web: System.Web.Http.Les filtres.ActionFilterAttribute -> c'est ce que vous avez besoin pour mettre en œuvre

Il semble que ce que vous avez montré est une Web API contrôleur de l'action (qui est déclarée à l'intérieur d'un contrôleur découlant de ApiController). Donc, si vous voulez appliquer des filtres personnalisés pour cela, ils doivent dériver de System.Web.Http.Filters.ActionFilterAttribute.

Donc, nous allons aller de l'avant et d'adapter le code de l'API Web:

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())
);
}
}
}

où la GetClientIp méthode vient de ce post.

Maintenant, vous pouvez utiliser cet attribut sur votre site Web API contrôleur de l'action.

WebApiThrottle est tout à fait le champion de maintenant dans ce domaine.

C'est super facile à intégrer. Il suffit d'ajouter le suivant à 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()
});

Il est disponible comme un nuget trop avec le même nom.

Je suis en utilisant ThrottleAttribute de limiter le taux d'appel de mon court-envoi d'un message de l'API, mais je l'ai trouvé ne fonctionne pas parfois. L'API peut être appelé plusieurs fois jusqu'à ce que la manette des gaz logique fonctionne, enfin je suis en utilisant System.Web.Caching.MemoryCache au lieu de HttpRuntime.Cache et le problème semble résolu.

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