Comment puis-je créer une contrainte de route de type System.Guid?

Question

Quelqu'un peut-il me diriger dans la bonne direction sur la façon de cartographier un itinéraire qui nécessite deux guids?

ie. http://blah.com/somecontroller/someaction/ {firstGuid}/{secondGuid}

où firstGuid et secondGuid ne sont pas facultatifs et doivent être de type system.Guid?

Answer 1

Créer une RouteConstraint comme ce qui suit:

public class GuidConstraint : IRouteConstraint { 

public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) 
{ 
    if (values.ContainsKey(parameterName)) 
    { 
     string stringValue = values[parameterName] as string; 

     if (!string.IsNullOrEmpty(stringValue)) 
     { 
      Guid guidValue; 

      return Guid.TryParse(stringValue, out guidValue) && (guidValue != Guid.Empty); 
     } 
    } 

    return false; 
}} 

suivant lors de l'ajout de la route:

routes.MapRoute("doubleGuid", "{controller}/{action}/{guid1}/{guid2}", new { controller = "YourController", action = "YourAction" }, new { guid1 = new GuidConstraint(), guid2 = new GuidConstraint() }); 

Answer 2

+1 @kazimanzurrashid. Semble tache sur.

Je vais donner une alternative pour ceux qui n'ont pas C# 4.0, dont Guid.TryParse fait partie. Il y a une autre alternative avec Regex mais probably not worth the bother.

public class GuidConstraint : IRouteConstraint 
    { 

     public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) 
     { 
      if (values.ContainsKey(parameterName)) 
      { 
       string stringValue = values[parameterName] as string; 

       if (!string.IsNullOrEmpty(stringValue)) 
       { 
        //replace with Guid.TryParse when available. 
        try 
        { 
         Guid guid = new Guid(stringValue); 
         return true; 
        } 
        catch 
        { 
         return false; 
        } 


       } 
      } 

      return false; 
     } 
    } 

Answer 3

Si vous utilisez le code de kazimanzurrashid, assurez-vous d'inclure le commentaire de Nikos D'. Je me suis retrouvé avec ceci:

public class NonEmptyGuidRouteConstraint : IRouteConstraint 
{ 
    public bool Match(HttpContextBase httpContext, Route route, 
     string parameterName, RouteValueDictionary values, RouteDirection routeDirection) 
    { 
     if (values.ContainsKey(parameterName)) 
     { 
      var guid = values[parameterName] as Guid?; 
      if (!guid.HasValue) 
      { 
       var stringValue = values[parameterName] as string; 
       if (!string.IsNullOrWhiteSpace(stringValue)) 
       { 
        Guid parsedGuid; 
        Guid.TryParse(stringValue, out parsedGuid); 
        guid = parsedGuid; 
       } 
      } 
      return (guid.HasValue && guid.Value != Guid.Empty); 
     } 
     return false; 
    } 
} 

Answer 4

Méfiez-vous du code donné par @kazimanzurrashid. C'était un bon début, mais il a certainement un bug ou aussi. Je passais un vrai Guid dans les valeurs de route (au lieu d'une chaîne de Guid), et je ne pouvais rien obtenir pour correspondre à mon itinéraire. Il m'a fallu une éternité pour réaliser que le GuidConstraint était contraint par rapport à un vrai Guid, si cela a du sens. :)

Voici ce que j'ai fini avec, qui accepte tout type de données (pas seulement de la chaîne), est un peu plus rapide (je pense), et contient moins si le bloc imbrique.

public class GuidConstraint : IRouteConstraint 
{ 

    public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) 
    { 
     object value; 
     if (!values.TryGetValue(parameterName, out value)) return false; 
     if (value is Guid) return true; 

     var stringValue = Convert.ToString(value); 
     if (string.IsNullOrWhiteSpace(stringValue)) return false; 

     Guid guidValue; 
     if (!Guid.TryParse(stringValue, out guidValue)) return false; 
     if (guidValue == Guid.Empty) return false; 

     return true; 
    } 
} 

Answer 5

Je trouve que en supposant que le type est un Guid fait problème lors de l'utilisation des choses comme @ Html.RouteLink (...) et dans les tests de routage où l'URL est fournie en tant que chaîne. Le code ci-dessous répond à ces situations. En utilisant les exemples de code ci-dessus causé des problèmes dans mes vues et/ou des tests, ce qui suit fonctionne très bien.

public class GuidConstraint : IRouteConstraint 
{ 
    public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection) 
    { 
     var value = values[parameterName]; 
     if (value == null) return false; 
     var stringValue = value.ToString(); 

     if (string.IsNullOrEmpty(stringValue)) return false; 
     Guid guidValue; 
     return Guid.TryParse(stringValue, out guidValue) && (guidValue != Guid.Empty); 
    } 
} 

Answer 6

Pour MVC 5 il est déjà mis en œuvre la GuidRouteConstraint Classe:
https://msdn.microsoft.com/en-us/library/system.web.mvc.routing.constraints.guidrouteconstraint(v=vs.118).aspx

Liste complète des contraintes disponibles MVC:
https://msdn.microsoft.com/en-us/library/system.web.mvc.routing.constraints(v=vs.118).