public static void AddCustomApiVersioning(this IServiceCollection services)
{
services.AddApiVersioning(options =>
{
//url segment => {version}
options.AssumeDefaultVersionWhenUnspecified = true; //default => false;
options.DefaultApiVersion = new ApiVersion(1, 0); //v1.0 == v1
options.ReportApiVersions = true;
ApiVersion.TryParse("1.0", out var version10);
ApiVersion.TryParse("1", out var version1);
var a = version10 == version1;
//options.ApiVersionReader = new QueryStringApiVersionReader("api-version");
// api/posts?api-version=1
//options.ApiVersionReader = new UrlSegmentApiVersionReader();
// api/v1/posts
//options.ApiVersionReader = new HeaderApiVersionReader(new[] { "Api-Version" });
// header => Api-Version : 1
//options.ApiVersionReader = new MediaTypeApiVersionReader()
//options.ApiVersionReader = ApiVersionReader.Combine(new QueryStringApiVersionReader("api-version"), new UrlSegmentApiVersionReader())
// combine of [querystring] & [urlsegment]
});
}
private static IServiceCollection AddVersioning(this IServiceCollection services)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var appOptions = services.BuildServiceProvider().GetService <AppOptions>() ?? new AppOptions();
var success = ApiVersion.TryParse(appOptions.Version, out var apiVersion);
if (!success)
{
apiVersion = new ApiVersion(1, 0);
}
return(services
.AddApiVersioning(x =>
{
x.ReportApiVersions = true;
x.DefaultApiVersion = apiVersion;
x.AssumeDefaultVersionWhenUnspecified = true;
x.ApiVersionReader = new HeaderApiVersionReader("x-api-version");
}));
}
/// <summary>
/// Applies a controller convention given the specified builder and model.
/// </summary>
/// <param name="controller">The <see cref="IControllerConventionBuilder">builder</see> used to apply conventions.</param>
/// <param name="controllerDescriptor">The <see cref="HttpControllerDescriptor">descriptor</see> to build conventions from.</param>
/// <returns>True if any conventions were applied to the <paramref name="controllerDescriptor">descriptor</paramref>;
/// otherwise, false.</returns>
public virtual bool Apply(IControllerConventionBuilder controller, HttpControllerDescriptor controllerDescriptor)
{
Arg.NotNull(controller, nameof(controller));
Arg.NotNull(controllerDescriptor, nameof(controller));
var text = GetRawApiVersion(controllerDescriptor.ControllerType.Namespace);
if (!ApiVersion.TryParse(text, out var apiVersion))
{
return(false);
}
var deprecated = controllerDescriptor.GetCustomAttributes <ObsoleteAttribute>().Any();
if (deprecated)
{
controller.HasDeprecatedApiVersion(apiVersion);
}
else
{
controller.HasApiVersion(apiVersion);
}
return(true);
}
/// <summary>
/// Applies a controller convention given the specified builder and model.
/// </summary>
/// <param name="controller">The <see cref="IControllerConventionBuilder">builder</see> used to apply conventions.</param>
/// <param name="controllerModel">The <see cref="ControllerModel">model</see> to build conventions from.</param>
/// <returns>True if any conventions were applied to the <paramref name="controllerModel">controller model</paramref>;
/// otherwise, false.</returns>
public virtual bool Apply(IControllerConventionBuilder controller, ControllerModel controllerModel)
{
if (controller == null)
{
throw new ArgumentNullException(nameof(controller));
}
if (controllerModel == null)
{
throw new ArgumentNullException(nameof(controllerModel));
}
var text = GetRawApiVersion(controllerModel.ControllerType.Namespace !);
if (!ApiVersion.TryParse(text, out var apiVersion))
{
return(false);
}
var deprecated = controllerModel.Attributes.OfType <ObsoleteAttribute>().Any();
if (deprecated)
{
controller.HasDeprecatedApiVersion(apiVersion !);
}
else
{
controller.HasApiVersion(apiVersion !);
}
return(true);
}
/// <summary>
/// Applies a controller convention given the specified builder and model.
/// </summary>
/// <param name="controller">The <see cref="IApiVersionConventionBuilder">builder</see> used to apply conventions.</param>
/// <param name="controllerModel">The <see cref="ControllerModel">model</see> to build conventions from.</param>
/// <returns>True if any conventions were applied to the <paramref name="controllerModel">controller model</paramref>;
/// otherwise, false.</returns>
public virtual bool Apply(IApiVersionConventionBuilder controller, ControllerModel controllerModel)
{
Arg.NotNull(controller, nameof(controller));
Arg.NotNull(controllerModel, nameof(controller));
var text = GetRawApiVersion(controllerModel.ControllerType.Namespace);
if (!ApiVersion.TryParse(text, out var apiVersion))
{
return(false);
}
var deprecated = controllerModel.Attributes.OfType <ObsoleteAttribute>().Any();
if (deprecated)
{
controller.HasDeprecatedApiVersion(apiVersion);
}
else
{
controller.HasApiVersion(apiVersion);
}
return(true);
}
public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName,
IDictionary <string, object> values, HttpRouteDirection routeDirection)
{
if (string.IsNullOrEmpty(parameterName))
{
return(false);
}
var properties = request.ApiVersionProperties();
var versionString = "";
if (values.TryGetValue(parameterName, out object value))
{
//This is the real 'magic' here, just replacing the underscore with a period
versionString = ((string)value).Replace('_', '.');
properties.RawApiVersion = versionString;
}
else
{
return(false);
}
if (ApiVersion.TryParse(versionString, out var requestedVersion))
{
properties.ApiVersion = requestedVersion;
return(true);
}
return(false);
}
public void try_parse_should_return_false_when_text_is_invalid(string text)
{
// arrange
var apiVersion = default(ApiVersion);
// act
var result = ApiVersion.TryParse(text, out apiVersion);
// assert
result.Should().BeFalse();
apiVersion.Should().BeNull();
}
public static void AddCustomApiVersioning(this IServiceCollection services)
{
services.AddApiVersioning(options =>
{
options.AssumeDefaultVersionWhenUnspecified = true;
options.DefaultApiVersion = new ApiVersion(1, 0);
options.ReportApiVersions = true;
ApiVersion.TryParse("1.0", out var version10);
ApiVersion.TryParse("1", out var version1);
var a = version10 == version1;
});
}
public void api_version_1_ge_api_version_2_should_return_expected_result(string versionValue, string otherVersionValue, bool expected)
{
// arrange
ApiVersion version = null;
ApiVersion otherVersion = null;
ApiVersion.TryParse(versionValue, out version);
ApiVersion.TryParse(otherVersionValue, out otherVersion);
// act
var result = version >= otherVersion;
// assert
result.Should().Be(expected);
}
public void try_parse_should_return_expected_api_version(string text, string groupVersionValue, int?majorVersion, int?minorVersion, string status)
{
// arrange
var groupVersion = groupVersionValue == null ? null : new DateTime?(Parse(groupVersionValue));
var apiVersion = default(ApiVersion);
// act
var result = ApiVersion.TryParse(text, out apiVersion);
// assert
result.Should().BeTrue();
apiVersion.ShouldBeEquivalentTo(
new
{
GroupVersion = groupVersion,
MajorVersion = majorVersion,
MinorVersion = minorVersion,
Status = status
});
}
private static IServiceCollection AddVersioning(this IServiceCollection services, AppOptions appOptions)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (appOptions == null)
{
throw new ArgumentNullException(nameof(appOptions));
}
ApiVersion.TryParse(appOptions.Version, out var apiVersion);
return(services
.AddApiVersioning(x =>
{
x.ReportApiVersions = true;
x.DefaultApiVersion = apiVersion ?? new ApiVersion(1, 0);
x.AssumeDefaultVersionWhenUnspecified = true;
x.ApiVersionReader = new HeaderApiVersionReader("x-api-version");
}));
}
