If you were looking for information about API<\/i> versioning support for ASP.NET Core<\/i> you’ve probably come across Microsoft.AspNetCore.Mvc.Versioning<\/a> library. The library itself allows you to set up versioning in a couple of different ways, for instance, via attributes<\/a> or via manual convention setup<\/a>. All of this options are really nice but unfortunately, they have one significant drawback, namely, you have to set them up manually. As I tend to forget about this kind of things I wanted to automate that process as much as possible. Thankfully ASP.NET Core<\/i> has a very nice feature called ApplicationModelConventions<\/i> which allows you to add some metadata(like routing information, API<\/i> versioning ) to your controller, actions etc.<\/p>\n I’ve decided to implement versioning by routing which means the API<\/i> will be accessible via this template<\/p>\n The template itself doesn\u2019t give you much, as you also have to add information to the controllers which version of API<\/i> they support. In my case, I decided to go with a version by namespace convention, which means that supported version will be deduced from namespace in which given controller resides. So, in fact, there will be two conventions, one for applying routing and a second one for applying versioning<\/p>\n In order to write an ASP.NET Core<\/i> convention, we have to implement IApplicationModelConvention<\/i> interface. This interface has a single method Apply<\/i> which takes ApplicationModel<\/i> class as an argument. This class gives us access to all of our controllers, actions and other parts of the application. So if we want to apply a routing with versioning for all of the controllers, we can do it in following way<\/p>\n As you can see we iterate through all of the Selectors<\/i> and then apply new route model to them. If selector already had a route attribute applied we combine two attributes together. Once our convention is applied our actions will be accessible with following routing prefix<\/p>\n or via <\/p>\n Having our routing ready now it is time to add versioning information to our controllers. Once again it will be done via application model convention. The version of the controller will be deduced from the namespace given controller is located in. <\/p>\n As you can see I iterate through all of the controller models of our application, then check the version of controller based on its namespace and finally with <\/p>\n I am able to inform the framework which version of API<\/i> given controller supports.<\/p>\n Having all of our conventions prepared now we can enable versioning support<\/p>\n And of course, we have to add newly created conventions to list of application conventions<\/p>\n Note that I removed ApiVersionConvention<\/i> and ImplicitControllerVersionConvention<\/i> with simple extension method Remove<T><\/i><\/p>\n to make sure that only my convention is responsible for API versioning.<\/p>\n2. Convention<\/h3>\n
\r\n\"v{version:apiVersion}\/[controller]\"\r\n<\/pre>\n3. Creating conventions.<\/h3>\n
\r\npublic class ApiVersionRoutePrefixConvention : IApplicationModelConvention\r\n{\r\n private readonly string _versionConstraintTemplate;\r\n private readonly string _versionedControllerTemplate;\r\n\r\n public ApiVersionRoutePrefixConvention()\r\n {\r\n _versionConstraintTemplate = \"v{version:apiVersion}\";\r\n _versionedControllerTemplate = $\"{_versionConstraintTemplate}\/[controller]\";\r\n }\r\n\r\n public void Apply(ApplicationModel application)\r\n {\r\n foreach (var applicationController in application.Controllers)\r\n {\r\n foreach (var applicationControllerSelector in applicationController.Selectors)\r\n {\r\n if (applicationControllerSelector.AttributeRouteModel != null)\r\n {\r\n var versionedConstraintRouteModel = new AttributeRouteModel\r\n {\r\n Template = _versionConstraintTemplate\r\n };\r\n\r\n applicationControllerSelector.AttributeRouteModel =\r\n AttributeRouteModel.CombineAttributeRouteModel(versionedConstraintRouteModel,\r\n applicationControllerSelector.AttributeRouteModel);\r\n }\r\n else\r\n {\r\n applicationControllerSelector.AttributeRouteModel = new AttributeRouteModel\r\n {\r\n Template = _versionedControllerTemplate\r\n };\r\n }\r\n }\r\n }\r\n }\r\n}\r\n<\/pre>\n\r\n\"v{version:apiVersion}\/[controller]\" \r\n<\/pre>\n\r\n\"v{version:apiVersion}\/previous_route_for_controller\"\r\n<\/pre>\n\r\npublic class ApiVersionByNamespaceConvention : IApplicationModelConvention\r\n{\r\n public void Apply(ApplicationModel application)\r\n {\r\n foreach (var controllerModel in application.Controllers)\r\n {\r\n var version = DeduceControllerVersion(controllerModel);\r\n var builder = new ControllerApiVersionConventionBuilder\r\nvar builder = new ControllerApiVersionConventionBuilder
4. Adding convention to application<\/h3>\n
\r\n\/\/ Add framework services.\r\nservices.AddApiVersioning(options =>\r\n{\r\n options.ReportApiVersions = true;\r\n});\r\n<\/pre>\n\r\nservices.AddMvc(options =>\r\n{\r\n options.Conventions.Remove\r\npublic static class CollectionExtensions\r\n{\r\n public static void Remove