Enabling Attribute Routing To enable attribute routing, call MapMvcAttributeRoutes during configuration.

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute(“{resource}.axd/{*pathInfo}”);

routes.MapMvcAttributeRoutes();

routes.MapRoute(
    name: “Default”,
    url: “{controller}/{action}/{id}”,
    defaults: new { controller = “Home”, action = “Index”, id = UrlParameter.Optional }
);
}

You can make a URI parameter optional by adding a question mark to the route parameter. You can also specify a default value by using the form parameter=value.

public class BooksController : Controller
{
    // eg: /books
    // eg: /books/1430210079
    [Route(“books/{isbn?}”)]
    public ActionResult View(string isbn)
    {
        if (!String.IsNullOrEmpty(isbn))
        {
            return View(“OneBook”, GetBook(isbn));
        }
        return View(“AllBooks”, GetBooks());
    }

// eg: /books/lang
// eg: /books/lang/en
// eg: /books/lang/he
[Route(“books/lang/{lang=en}”)]
public ActionResult ViewByLanguage(string lang)
{
    return View(“OneBook”, GetBooksByLanguage(lang));
}

In this example, both /books and /books/1430210079 will route to the “View” action, the former will result with listing all books, and the latter will list the specific book. Both /books/lang and /books/lang/en will be treated the same.

Often, the routes in a controller all start with the same prefix. For example:

public class ReviewsController : Controller
{
    // eg: /reviews
    [Route(“reviews”)]
    public ActionResult Index() { … }
    // eg: /reviews/5
    [Route(“reviews/{reviewId}”)]
    public ActionResult Show(int reviewId) { … }
    // eg: /reviews/5/edit
    [Route(“reviews/{reviewId}/edit”)]
    public ActionResult Edit(int reviewId) { … }
}

You can set a common prefix for an entire controller by using the [RoutePrefix] attribute:

[RoutePrefix(“reviews”)]
public class ReviewsController : Controller
{
    // eg.: /reviews
    [Route]
    public ActionResult Index() { … }
    // eg.: /reviews/5
    [Route(“{reviewId}”)]
    public ActionResult Show(int reviewId) { … }
    // eg.: /reviews/5/edit
    [Route(“{reviewId}/edit”)]
    public ActionResult Edit(int reviewId) { … }
}

Use a tilde (~) on the method attribute to override the route prefix if needed:

[RoutePrefix(“reviews”)]
public class ReviewsController : Controller
{
    // eg.: /spotlight-review
    [Route(“~/spotlight-review”)]
    public ActionResult ShowSpotlight() { … }
 
    …
}

You can also apply the [Route] attribute on the controller level, capturing the action as a parameter. That route would then be applied on all actions in the controller, unless a specific [Route] has been defined on a specific action, overriding the default set on the controller.

[RoutePrefix(“promotions”)]
[Route(“{action=index}”)]
public class ReviewsController : Controller
{
    // eg.: /promotions
    public ActionResult Index() { … }
 
    // eg.: /promotions/archive
    public ActionResult Archive() { … }
 
    // eg.: /promotions/new
    public ActionResult New() { … }
 
    // eg.: /promotions/edit/5
    [Route(“edit/{promoId:int}”)]
    public ActionResult Edit(int promoId) { … }
}

Route constraints let you restrict how the parameters in the route template are matched. The general syntax is {parameter:constraint}. For example:

// eg: /users/5
[Route(“users/{id:int}”]
public ActionResult GetUserById(int id) { … }
 
// eg: users/ken
[Route(“users/{name}”]
public ActionResult GetUserByName(string name) { … }

Here, the first route will only be selected if the “id” segment of the URI is an integer. Otherwise, the second route will be chosen.

Const	Description (Matches:)	Example
alpha	Uppercase or lowercase Latin alphabet characters (a-z, A-Z)	{x:alpha}
bool	Boolean value.	{x:bool}
datetime	DateTime value.	{x:datetime}
decimal	Decimal value.	{x:decimal}
double	64-bit floating-point value.	{x:double}
float	32-bit floating-point value.	{x:float}
guid	GUID value.	{x:guid}
int	32-bit integer value.	{x:int}
length	String with the specified length or within a specified range of lengths.	{x:length(6)} {x:length(1,20)}
long	64-bit integer value.	{x:long}
max	Integer with a maximum value.	{x:max(10)}
maxlength	String with a maximum length.	{x:maxlength(10)}
min	Integer with a minimum value.	{x:min(10)}
minlength	String with a minimum length.	{x:minlength(10)}
range	Integer within a range of values.	{x:range(10,50)}
regex	Regular expression.	{x:regex(^\d{3}-\d{3}-\d{4}$)}