Personnaliser MapHttpAttributeRoutes pour le Web Api de gestion des versions

Je suis la mise en œuvre de l'API Web de gestion des versions comme dans L'API Web de gestion des versions. Mon contrôleurs sont dans 2 espaces de noms, et j'ai utilisé une coutume SelectController de la méthode à choisir la version à utiliser sur la base d'un paramètre de requête.
par exemple,

http://myapi/api/values?version=1.0

Tout cela fonctionne très bien mais certaines actions dans l'utilisation de contrôleurs de la Route attribut

[Route("api/values/getNames")]
public HttpResponseMessage Get() { ... }

Qui sont mappés à la bonne contrôleur par défaut à l'aide de

config.MapHttpAttributeRoutes();

dans WebApiConfig.cs

Cela ne fonctionnera pas si j'ai plusieurs versions de l'API avec le même itinéraire. Suis-je en mesure de fournir une implémentation personnalisée de config.MapHttpAttributeRoutes() pour que je puisse sélectionner la bonne version de l'API à utiliser, ou est-il une meilleure manière de faire ceci?

OriginalL'auteur nickela125 | 2014-08-14

  1. 11

    Il est un exemple de cela dans l'officiel WebApi 2.1 examplex sur Codeplex.
    Il s'appuie sur un en-tête de requête de la valeur à stocker la version.

    Je pense que c'est beaucoup plus agréable, car il permet à l'routes de rester le même pour toutes les versions. Les Clients de sélectionner la version simplement en incluant un en-tête HTTP de la requête (dans ce cas, le numéro de version).

    Cet exemple montre comment utiliser l'Attribut de Routage et des Contraintes dans l'
    ASP.NET Web API pour filtrer dynamiquement les contrôleurs par une " api-version
    L'en-tête HTTP. Lorsqu'un itinéraire utilise des Contraintes, chaque contrainte a un
    chance pour prévenir la route de correspondant à une requête donnée. Dans ce
    exemple, une coutume RouteFactoryAttribute (VersionedRoute) ajoute un
    contrainte pour chaque attribut de la route.

    ...

    La coutume de contrainte de mise en œuvre (VersionConstraint) est
    en fonction de la valeur de 'api-version correspondant à un nombre entier
    de la valeur. La valeur des permis de version pour la contrainte est fourni
    par la VersionedRoute attribut placé sur chaque contrôleur. Lorsqu'un
    demande, la valeur d'en-tête de 'api-version est en correspondance avec
    la version attendue. Cet exemple utilise un en-tête, mais une contrainte
    la mise en œuvre pourrait utiliser des critères permettant de décider si la demande est
    valable pour la route.

    De toute façon, le résultat final serait finir par ressembler à cela:

    [VersionedRoute("api/Customer", 1)]
public class CustomerVersion1Controller : ApiController
{
    //controller code goes here
}
[VersionedRoute("api/Customer", 2)]
public class CustomerVersion2Controller : ApiController
{
    //controller code goes here
}
    Cela ressemble à une bonne solution, mais malheureusement, je dois utiliser un paramètre de requête, et il ne sera pas un nombre entier, il aura le format de major-version.minor-version ou une date
    Je pense que vous pouvez régler de leur exemple pour utiliser un paramètre de requête au lieu de cela, dans le format que vous souhaitez.

    OriginalL'auteur Marcel N.

  2. 5

    Voici une solution qui vous permettra d'utiliser le Web API 2 chemin des versions d'itinéraires (en-têtes), en plus des paramètres de la requête de soutien (c'est à dire utiliser un en-tête appelé "api-version ou un paramètre de chaîne de requête nommée"?api-version=XXX'.

    HTTP Route contrainte ne l'oeuvre:

    ///<summary>
///Add a route constraint to detect version header or by query string
///</summary>
public class RouteVersionHttpConstraint : IHttpRouteConstraint
{
public const string VersionHeaderName = "api-version";
private const int DefaultVersion = 1;
///<summary>
///Add a route constraint to detect version header or by query string
///</summary>
///<param name="allowedVersion"></param>
public RouteVersionHttpConstraint(int allowedVersion)
{
AllowedVersion = allowedVersion;
}
public int AllowedVersion
{
get;
private set;
}
///<summary>
///Perform the controller match
///</summary>
///<param name="request"></param>
///<param name="route"></param>
///<param name="parameterName"></param>
///<param name="values"></param>
///<param name="routeDirection"></param>
///<returns></returns>
public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
{
if (routeDirection == HttpRouteDirection.UriResolution)
{
int version = GetVersionHeaderOrQuery(request) ?? DefaultVersion;
if (version == AllowedVersion)
{
return true;
}
}
return false;
}
///<summary>
///Check the request header, and the query string to determine if a version number has been provided
///</summary>
///<param name="request"></param>
///<returns></returns>
private int? GetVersionHeaderOrQuery(HttpRequestMessage request)
{
string versionAsString;
IEnumerable<string> headerValues;
if (request.Headers.TryGetValues(VersionHeaderName, out headerValues) && headerValues.Count() == 1)
{
versionAsString = headerValues.First();
int version;
if (versionAsString != null && Int32.TryParse(versionAsString, out version))
{
return version;
}
}
else
{
var query = System.Web.HttpUtility.ParseQueryString(request.RequestUri.Query);
string versionStr = query[VersionHeaderName];
int version = 0;
int.TryParse(versionStr, out version);
if (version > 0)
return version;
}
return null;
}
}

    Et de la route de l'usine:

    ///<summary>
///Versioning support for the WebAPI controllers
///</summary>
public class RouteVersionAttribute : RouteFactoryAttribute
{
public int Version { get; private set; }
public RouteVersionAttribute() : this(null, 1) 
{ 
}
///<summary>
///Specify a version for the WebAPI controller
///</summary>
///<param name="version"></param>
public RouteVersionAttribute(int version) : this(null, version)
{
}
public RouteVersionAttribute(string template, int version)
: base(template)
{
Version = version;
}
public override IDictionary<string, object> Constraints
{
get
{
var constraints = new HttpRouteValueDictionary();
constraints.Add("version", new RouteVersionHttpConstraint(Version));
return constraints;
}
}
public override IDictionary<string, object> Defaults
{
get
{
var defaults = new HttpRouteValueDictionary();
defaults.Add("version", 1);
return defaults;
}
}
}

    Utilisation:

    [RouteVersion("api/versiontest", 1)]
public class Version1TestController : BaseApiController
{
//get: api/versiontest
[HttpGet]
public HttpResponseMessage get()
{
return Request.CreateResponse(HttpStatusCode.OK, new { Version = "API Version 1 selected" });
}
}
[RouteVersion("api/versiontest", 2)]
public class Version2TestController : ApiController
{
//get: api/versiontest
[HttpGet]
public HttpResponseMessage get()
{
return Request.CreateResponse(HttpStatusCode.OK, new { Version = "API Version 2 selected" });
}
}

    OriginalL'auteur Michael Brown