public static void Register(HttpConfiguration config)
{
AutofacConfig.Register();
config.AddApiVersioning(opt =>
{
opt.DefaultApiVersion = new ApiVersion(1, 1);
opt.AssumeDefaultVersionWhenUnspecified = true;
opt.ReportApiVersions = true;
//opt.ApiVersionReader = ApiVersionReader.Combine
//(new HeaderApiVersionReader("X-Version"), new QueryStringApiVersionReader("ver"));
opt.ApiVersionReader = new UrlSegmentApiVersionReader();
});
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver
= new CamelCasePropertyNamesContractResolver();
var contractResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) }
};
config.MapHttpAttributeRoutes(contractResolver);
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
}
public static void Configure(HttpConfiguration config)
{
// Map attribute routes
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
config.AddApiVersioning(o => o.ReportApiVersions = true);
config.MapHttpAttributeRoutes(constraintResolver);
config.Filters.Add(new CustomResourceAuthorizeAttribute());
config.Filters.Add(new ValidationErrorAttribute());
// Show errors to local requests
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.LocalOnly;
// Remove Xml serializer
config.Formatters.Remove(config.Formatters.XmlFormatter);
CustomizeServices(config);
ConfigureJsonSerialization(config.Formatters.JsonFormatter.SerializerSettings);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
AutofacConfig.Register();
config.AddApiVersioning(cfg =>
{
cfg.DefaultApiVersion = new ApiVersion(1, 1);
cfg.AssumeDefaultVersionWhenUnspecified = true;
cfg.ReportApiVersions = true;
cfg.ApiVersionReader = ApiVersionReader.Combine(
new HeaderApiVersionReader("X-Version"),
new QueryStringApiVersionReader("ver"));
});
// Change Case of JSON
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
new CamelCasePropertyNamesContractResolver();
// Web API routes
config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
}
/// <summary>
/// Register Method
/// </summary>
public static void Register(HttpConfiguration configuration)
{
// Swagger API Multiple Versions
configuration.AddApiVersioning(apiVersionInfo => apiVersionInfo.AssumeDefaultVersionWhenUnspecified = true);
var apiExplorer = configuration.AddVersionedApiExplorer(options =>
{
options.GroupNameFormat = "'v'VVV";
});
configuration
.EnableSwagger("swagger/docs/{apiVersion}", swagger =>
{
{
swagger.MultipleApiVersions(
(apiDescription, version) => apiDescription.GetGroupName() == version,
info =>
{
foreach (var group in apiExplorer.ApiDescriptions)
{
info.Version(group.Name, $"DH.Media.API v{group.ApiVersion}");
}
});
}
swagger.OperationFilter <RequiredHeaderParameter>();
swagger.IncludeXmlComments(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data\\MediaApiDoc.xml"));
swagger.DescribeAllEnumsAsStrings();
swagger.SchemaId(x => x.FullName);
})
.EnableSwaggerUi(swaggerUi =>
{
swaggerUi.EnableDiscoveryUrlSelector();
});
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
// HACK: Microsoft.AspNet.WebApi.Versioning on Nuget, will add versioning for your API
config.AddApiVersioning(cfg =>
{
cfg.DefaultApiVersion = new ApiVersion(1, 0);
cfg.AssumeDefaultVersionWhenUnspecified = true;
cfg.ReportApiVersions = true;
// HACK: If you don't set this, the default version reader is QueryStringApiVersionReader
cfg.ApiVersionReader = new HeaderApiVersionReader("X-Version");
// HACK: You can specify multiple version methods as per below
//cfg.ApiVersionReader = ApiVersionReader.Combine(new QueryStringApiVersionReader(), new HeaderApiVersionReader("X-Version"));
});
// HACK: Have to manually add this contract resolver to sort out the camel casing
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
//// Web API configuration and services
var container = new UnityContainer();
RegisterDataServices.Register(container);
RegisterMappers.Register(container);
RegisterServices.Register(container);
RegisterFacades.Register(container);
config.DependencyResolver = new UnityResolver(container);
config.AddApiVersioning(v => v.AssumeDefaultVersionWhenUnspecified = true);
// Web API routes
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) }
};
// Web API routes
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public void apply_to_should_assign_conventions_to_controller()
{
// arrange
var configuration = new HttpConfiguration();
var mock = new Mock <HttpControllerDescriptor>()
{
CallBase = true
};
var controllerDescriptor = mock.Object;
var controllerBuilder = default(ControllerApiVersionConventionBuilder <UndecoratedController>);
mock.Setup(cd => cd.GetCustomAttributes <IApiVersionProvider>()).Returns(new Collection <IApiVersionProvider>());
controllerDescriptor.Configuration = configuration;
controllerDescriptor.ControllerType = typeof(UndecoratedController);
configuration.AddApiVersioning(o => controllerBuilder = o.Conventions.Controller <UndecoratedController>());
controllerBuilder.HasDeprecatedApiVersion(0, 9)
.HasApiVersion(2, 0)
.AdvertisesApiVersion(3, 0)
.AdvertisesDeprecatedApiVersion(3, 0, "Beta");
// act
controllerBuilder.ApplyTo(controllerDescriptor);
// assert
controllerDescriptor.GetApiVersionModel().ShouldBeEquivalentTo(
new
{
IsApiVersionNeutral = false,
DeclaredApiVersions = new[] { new ApiVersion(0, 9), new ApiVersion(2, 0) },
SupportedApiVersions = new[] { new ApiVersion(2, 0), new ApiVersion(3, 0) },
DeprecatedApiVersions = new[] { new ApiVersion(0, 9), new ApiVersion(3, 0, "Beta") },
ImplementedApiVersions = new[] { new ApiVersion(0, 9), new ApiVersion(2, 0), new ApiVersion(3, 0), new ApiVersion(3, 0, "Beta") }
});
}
public void Configuration(IAppBuilder builder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
configuration.AddApiVersioning(
options =>
{
// reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions"
options.ReportApiVersions = true;
// automatically applies an api version based on the name of the defining controller's namespace
options.Conventions.Add(new VersionByNamespaceConvention());
});
// NOTE: you do NOT and should NOT use both the query string and url segment methods together.
// this configuration is merely illustrating that they can coexist and allows you to easily
// experiment with either configuration. one of these would be removed in a real application.
configuration.Routes.MapHttpRoute(
"VersionedQueryString",
"api/{controller}/{accountId}",
defaults: null);
configuration.Routes.MapHttpRoute(
"VersionedUrl",
"v{apiVersion}/{controller}/{accountId}",
defaults: null,
constraints: new { apiVersion = new ApiVersionRouteConstraint() });
builder.UseWebApi(httpServer);
}
public static void Register(HttpConfiguration config)
{
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
config.MapHttpAttributeRoutes(constraintResolver);
// Web API configuration and services
config.AddApiVersioning(o =>
{
o.DefaultApiVersion = new ApiVersion(1, 0);
o.AssumeDefaultVersionWhenUnspecified = true;
o.ReportApiVersions = true;
o.Conventions.Add(new RangedVersioningControllerConvention(ApiVersionConfig.GetCurrentVersions()));
});
// Web API routes
config.Routes.MapHttpRoute(
"VersionedQueryString",
"api/{controller}",
defaults: null);
}
public static void Register(HttpConfiguration config)
{
config.MessageHandlers.Add(new LoggingHandler());
// Web API configuration and services
config.Services.Replace(typeof(IHttpControllerActivator), new ServiceActivator(config));
// Web API routes
// Web API routes with versioning
var constraintResolver = new DefaultInlineConstraintResolver
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
config.MapHttpAttributeRoutes();
config.AddApiVersioning(options =>
{
options.AssumeDefaultVersionWhenUnspecified = true;
});
config.Filters.Add(new Filters.SEOExceptionFilterAttribute());
// Remove XML formatter
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new DefaultContractResolver();
config.Formatters.Remove(config.Formatters.XmlFormatter);
// Enable CORS
config.EnableCors();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
config.AddApiVersioning(o => o.ReportApiVersions = true);
// Web API routes
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
// config.MapHttpAttributeRoutes();
config.AddApiVersioning(o =>
{
o.ReportApiVersions = true;
o.ApiVersionReader = new UrlSegmentApiVersionReader();
});
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) }
};
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
SwaggerConfig.Register(config);
}
public static void RegisterWebApi(this HttpConfiguration config)
{
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) }
};
// Web API configuration and services
config.AddApiVersioning(o =>
{
o.AssumeDefaultVersionWhenUnspecified = true;
o.DefaultApiVersion = new Microsoft.Web.Http.ApiVersion(1, 0);
});
// Web API routes
config.MapHttpAttributeRoutes(constraintResolver);
////Registering GlobalExceptionHandler
config.Services.Replace(typeof(IExceptionHandler), new GlobalExceptionHandler());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.RegisterUnity();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Dependency Injection for WebApi controllers via StructureMap
config.Services.Replace(typeof(IHttpControllerActivator), new ServiceActivator(config));
// API Versioning (adding version to URL)
config.AddApiVersioning();
// make a constraint for API version
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
// Web API routes
config.MapHttpAttributeRoutes(constraintResolver);
// Add a filter to handle common exceptions and convert them into
// appropriate status codes.
config.Filters.Add(new WebApiExceptionFilter());
// Add converter to serialize enum types as their symbol name rather than their value
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
// Add JSON support for output (instead of XML) when text/html is requested
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
}
public static void Register(HttpConfiguration config)
{
config.AddApiVersioning(o =>
{
o.ReportApiVersions = true;
o.AssumeDefaultVersionWhenUnspecified = true;
o.DefaultApiVersion = new ApiVersion(2, 0);
o.ApiVersionReader = new HeaderApiVersionReader("version");
o.ApiVersionSelector = new CurrentImplementationApiVersionSelector(o);
}
);
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
// Web API configuration and services
config.Filters.Add(new CustomExceptionFilter());
config.Services.Replace(typeof(IExceptionHandler), new GlobalExceptionHandler());
//Registering UnhandledExceptionLogger
config.Services.Replace(typeof(IExceptionLogger), new UnhandledExceptionLogger());
//Registering RequestResponseHandler
//config.MessageHandlers.Add(new RequestResponseHandler());
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
}
public static void Register(HttpConfiguration config)
{
// added to the web api configuration in the application setup
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
// Web API routes
config.MapHttpAttributeRoutes(constraintResolver);
//register versioning service
config.AddApiVersioning();
// Web API configuration and services
config.Formatters.Insert(0, new MyDecimalFormatter());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
var httpServer = new HttpServer(config);
config.AddApiVersioning(o =>
{
o.ReportApiVersions = true;
o.AssumeDefaultVersionWhenUnspecified = true;
o.DefaultApiVersion = new ApiVersion(2, 0);
o.ApiVersionReader = new HeaderApiVersionReader("api-version");
o.ApiVersionSelector = new CurrentImplementationApiVersionSelector(o);
}
);
// config.MapHttpAttributeRoutes();
// app.UseWebApi(httpServer);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static HttpConfiguration NewOrdersConfiguration()
{
var configuration = new HttpConfiguration();
var controllerTypeResolver = new ControllerTypeCollection(
typeof(Simulators.V1.OrdersController),
typeof(Simulators.V2.OrdersController),
typeof(Simulators.V3.OrdersController));
configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver);
configuration.AddApiVersioning(
options =>
{
options.Conventions.Controller <Simulators.V1.OrdersController>()
.HasApiVersion(1, 0)
.HasDeprecatedApiVersion(0, 9)
.Action(c => c.Post(default(Order))).MapToApiVersion(1, 0);
options.Conventions.Controller <Simulators.V2.OrdersController>()
.HasApiVersion(2, 0);
options.Conventions.Controller <Simulators.V3.OrdersController>()
.HasApiVersion(3, 0)
.AdvertisesApiVersion(4, 0);
});
var builder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations = { new OrderModelConfiguration() }
};
var models = builder.GetEdmModels();
configuration.MapVersionedODataRoutes("odata", "api", models);
return(configuration);
}
public static void Register(
HttpConfiguration config)
{
// Web API configuration and services
// api version
var constraintResolver = new DefaultInlineConstraintResolver
{
ConstraintMap =
{
["apiVersion"] =
typeof(
ApiVersionRouteConstraint
)
}
};
config.MapHttpAttributeRoutes(constraintResolver);
config.AddApiVersioning();
// let's have a home page (which is our client app)
config.Routes.MapHttpRoute("Index", "{id}.html", new { id = "index" });
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
// json format
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
// xml format
var appXmlType =
config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
}
public static void Register(HttpConfiguration config)
{
// Web API 配置和服务
config.SuppressDefaultHostAuthentication();
//Configure Web API to use only bearer token authentication.
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// allow a client to call you without specifying an api version
// since we haven't configured it otherwise, the assumed api version will be 1.0
config.AddApiVersioning(o =>
{
o.AssumeDefaultVersionWhenUnspecified = true;
o.ReportApiVersions = true;
o.DefaultApiVersion = new Microsoft.Web.Http.ApiVersion(1, 0);
});
// added to the web api configuration in the application setup
var constraintResolver = new System.Web.Http.Routing.DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(Microsoft.Web.Http.Routing.ApiVersionRouteConstraint)
}
};
// Web API 路由
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
EnableCorsAttribute cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
config.MapHttpAttributeRoutes();
config.AddApiVersioning(o => o.ReportApiVersions = true);
IsoDateTimeConverter converter = new IsoDateTimeConverter
{
DateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"
};
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(converter);
config.Routes.MapHttpRoute(
"VersionedQueryString",
"{controller}/{id}",
defaults: null);
config.Routes.MapHttpRoute(
"VersionedUrl",
"v{apiVersion}/{controller}/{id}",
defaults: null,
constraints: new { apiVersion = new ApiVersionRouteConstraint() });
}
/// <summary>
/// Registers the specified configuration.
/// </summary>
/// <param name="config">The configuration.</param>
public static void Register(HttpConfiguration config)
{
// Web API routes
//adding the versioning to the API
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
config.MapHttpAttributeRoutes(constraintResolver);
config.AddApiVersioning();
//Registration for any unhandled exception is thrown anywhere
config.Services.Replace(typeof(IExceptionLogger), new UnhandledExceptionLogger());
//for general exception
config.Services.Replace(typeof(IExceptionHandler), new GlobalExceptionHandler());
//add custom validation
config.Filters.Add(new CustomExceptionHandlingAttribute());
}
public void Configuration(IAppBuilder appBuilder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
configuration.AddApiVersioning(
o =>
{
o.ReportApiVersions = true;
o.AssumeDefaultVersionWhenUnspecified = true;
o.ApiVersionReader = ApiVersionReader.Combine(
new QueryStringApiVersionReader(),
new HeaderApiVersionReader("api-version", "x-ms-version"));
});
var modelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelBuilderFactory = () => new ODataConventionModelBuilder().EnableLowerCamelCase(),
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration()
}
};
var models = modelBuilder.GetEdmModels();
var batchHandler = new DefaultODataBatchHandler(httpServer);
configuration.MapVersionedODataRoutes("odata", "api", models, OnConfigureContainer, batchHandler);
configuration.Routes.MapHttpRoute("orders", "api/{controller}/{id}", new { id = Optional });
appBuilder.UseWebApi(httpServer);
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
var httpServer = new HttpServer(config);
config.AddApiVersioning();
config.Select().Expand().Filter().OrderBy().MaxTop(null).Count();
var modelBuilder = new VersionedODataModelBuilder(config)
{
ModelBuilderFactory = () => new ODataConventionModelBuilder().EnableLowerCamelCase(),
ModelConfigurations =
{
new FlightPlanConfiguration(),
new FlightDetailsConfiguration()
}
};
var models = modelBuilder.GetEdmModels();
var batchHandler = new DefaultODataBatchHandler(httpServer);
var conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new CompositeKeyRoutingConvention());
config.MapVersionedODataRoutes("odata", "data/v{apiVersion}", models, ConfigureODataServices, batchHandler);
//config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
//config.MapVersionedODataRoutes("odata", "data/v{apiVersion}", models, new DefaultODataPathHandler(),conventions, batchHandler);
}
public void Configuration(IAppBuilder builder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
configuration.AddApiVersioning(options => options.ReportApiVersions = true);
//-----DATA-----
var modelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations = { new DataModelConfiguration() }
};
var models = modelBuilder.GetEdmModels();
configuration.MapVersionedODataRoutes("odata-data", "data/v{apiVersion}", models);
//-----CONFIG-----
var configModelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations = { new ConfigModelConfiguration() }
};
var configModels = configModelBuilder.GetEdmModels();
configuration.MapVersionedODataRoutes("odata-config", "config/v{apiVersion}", configModels);
var apiExplorer = configuration.AddODataApiExplorer(
options => {
options.GroupNameFormat = "'v'VVV";
options.SubstituteApiVersionInUrl = true;
});
builder.UseWebApi(httpServer);
}
public void Configuration(IAppBuilder builder)
{
// we only need to change the default constraint resolver for services that want urls with versioning like: ~/v{version}/{controller}
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) }
};
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
configuration.AddApiVersioning(
options =>
{
// reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions"
options.ReportApiVersions = true;
// apply api versions using conventions rather than attributes
options.Conventions.Controller <ValuesController>().HasApiVersion(1, 0);
options.Conventions.Controller <Values2Controller>()
.HasApiVersion(2, 0)
.HasApiVersion(3, 0)
.Action(c => c.GetV3()).MapToApiVersion(3, 0)
.Action(c => c.GetV3(default(int))).MapToApiVersion(3, 0);
options.Conventions.Controller <HelloWorldController>()
.HasApiVersion(1, 0)
.HasApiVersion(2, 0)
.AdvertisesApiVersion(3, 0);
});
configuration.MapHttpAttributeRoutes(constraintResolver);
builder.UseWebApi(httpServer);
}
public static void Register(HttpConfiguration config)
{
// Configuración y servicios de API web
#region Api Version
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap =
{
["apiVersion"] = typeof(ApiVersionRouteConstraint)
}
};
config.AddApiVersioning(o =>
{
o.ReportApiVersions = true;
o.AssumeDefaultVersionWhenUnspecified = true;
o.DefaultApiVersion = new ApiVersion(1, 0);
});
config.MapHttpAttributeRoutes(constraintResolver);
#endregion
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
/// <summary>
///
/// </summary>
/// <param name="config"></param>
public static void Register(HttpConfiguration config)
{
config.EnableCors();
// Web API configuration and services
config.DependencyResolver = new UnityResolver(UnityConfig.RegisterComponents());
// Web API routes
var constraintResolver = new DefaultInlineConstraintResolver()
{
ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) }
};
config.MapHttpAttributeRoutes(constraintResolver);
config.AddApiVersioning();
config.EnsureInitialized();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var formatters = config.Formatters;
var jsonFormatter = formatters.JsonFormatter;
var settings = jsonFormatter.SerializerSettings;
settings.Formatting = Formatting.Indented;
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
}
static HttpConfiguration NewConventionRouteConfiguration()
{
var configuration = new HttpConfiguration();
var controllerTypeResolver = new ControllerTypeCollection(
typeof(ValuesController),
typeof(Values2Controller),
typeof(Values3Controller));
configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver);
configuration.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = Optional });
configuration.AddApiVersioning(
options =>
{
options.Conventions.Controller <ValuesController>()
.HasApiVersion(1, 0);
options.Conventions.Controller <Values2Controller>()
.HasApiVersion(2, 0)
.HasDeprecatedApiVersion(3, 0, "beta")
.HasApiVersion(3, 0)
.Action(c => c.Post(default(ClassWithId))).MapToApiVersion(3, 0);
options.Conventions.Controller <Values3Controller>()
.HasApiVersion(4, 0)
.AdvertisesApiVersion(5, 0);
});
return(configuration);
}
public void apply_to_should_assign_model_to_controller_from_conventions_and_attributes()
{
// arrange
var configuration = new HttpConfiguration();
var mock = new Mock <HttpControllerDescriptor>()
{
CallBase = true
};
var controllerDescriptor = mock.Object;
var attributes = new Collection <IApiVersionProvider>(typeof(DecoratedController).GetCustomAttributes().OfType <IApiVersionProvider>().ToList());
var controllerBuilder = default(ControllerApiVersionConventionBuilder <DecoratedController>);
mock.Setup(cd => cd.GetCustomAttributes <IApiVersionProvider>()).Returns(attributes);
controllerDescriptor.Configuration = configuration;
controllerDescriptor.ControllerType = typeof(DecoratedController);
configuration.AddApiVersioning(o => controllerBuilder = o.Conventions.Controller <DecoratedController>());
controllerBuilder.HasApiVersion(1, 0)
.AdvertisesApiVersion(4, 0);
var actionDescriptor = configuration.Services.GetActionSelector().GetActionMapping(controllerDescriptor).SelectMany(g => g).Single();
// act
controllerBuilder.ApplyTo(controllerDescriptor);
// assert
actionDescriptor.GetApiVersionModel().Should().BeEquivalentTo(
new
{
IsApiVersionNeutral = false,
DeclaredApiVersions = new ApiVersion[0],
SupportedApiVersions = new[] { new ApiVersion(1, 0), new ApiVersion(2, 0), new ApiVersion(3, 0), new ApiVersion(4, 0) },
DeprecatedApiVersions = new[] { new ApiVersion(0, 9), new ApiVersion(3, 0, "Beta") },
ImplementedApiVersions = new[] { new ApiVersion(0, 9), new ApiVersion(1, 0), new ApiVersion(2, 0), new ApiVersion(3, 0), new ApiVersion(3, 0, "Beta"), new ApiVersion(4, 0) }
});
}
