NoSpoon

// I like this
Header 'Accept: application/json; v=1.0'
// vs this
Header 'Accept: application/vnd.myapp.v1.user+json'
// or this
Header 'api-version: 1.0'

public static class ApiVersionSetupExtensionMethods
{
    public static void AddApiVersioningAndExplorer(this IServiceCollection services)
    {
        // Add the versioned api explorer, which also adds IApiVersionDescriptionProvider service
        // Note: the specified format code will format the version as "'v'major[.minor][-status]"
        services.AddVersionedApiExplorer(
            options =>
            {
                options.GroupNameFormat = "'v'VVV";
            });

        services.AddApiVersioning(
            options =>
            {
                options.ReportApiVersions = true;

                    // Use this if you would like a new separate header to set the version in.
                    // Eg: Header 'api-version: 1.0'
                    //options.ApiVersionReader = new HeaderApiVersionReader("api-version");

                    // Use this if you would like to use the MediaType version header.
                    // Eg: Header 'Accept: application/json; v=1.0'
                    options.ApiVersionReader = new MediaTypeApiVersionReader();

                    // This is set to true so that we can set what version to select (default version)
                    // when no version has been selected.
                    options.AssumeDefaultVersionWhenUnspecified = true;
                    // And this is where we set how to select the default version. 
                    options.ApiVersionSelector = new CurrentImplementationApiVersionSelector(options);
            });
    }
}

public static class SwaggerGenerationSetupExtensionMethods
{
    public static void AddSwaggerGeneration(this IServiceCollection services)
    {
        services.AddSwaggerGen(options =>
        {
            // Resolve the IApiVersionDescriptionProvider service
            // Note: that we have to build a temporary service provider here because one has not been created yet
            using (var serviceProvider = services.BuildServiceProvider())
            {
                var provider = serviceProvider.GetRequiredService<IApiVersionDescriptionProvider>();

                // Add a swagger document for each discovered API version
                // Note: you might choose to skip or document deprecated API versions differently
                foreach (var description in provider.ApiVersionDescriptions)
                {
                    options.SwaggerDoc(description.GroupName, description.CreateInfoForApiVersion());
                }
            }

            // Add a custom operation filter which sets default values if you are using a separate header for version
            //options.OperationFilter<SwaggerDefaultValues>();

            // Integrate xml comments, add this when we have come that far.
            //options.IncludeXmlComments(XmlCommentsFilePath);

            // Describe all enums as strings instead of integers.
            //options.DescribeAllEnumsAsStrings();
        });
    }

    public static OpenApiInfo CreateInfoForApiVersion(this ApiVersionDescription description)
    {
        var info = new OpenApiInfo()
        {
            Title = $"Test API {description.ApiVersion}",
            Version = description.ApiVersion.ToString(),
            Description = "This is the swagger base info for API.",
            Contact = new OpenApiContact() { Name = "Contact Name", Email = "some@email.com" },
            //TermsOfService = "UnComment and put the URI here to the terms of service.",
            License = new OpenApiLicense() { Name = "MIT", Url = new Uri("https://opensource.org/licenses/MIT") }
        };

        if (description.IsDeprecated)
        {
            info.Description += " This API version has been deprecated.";
        }

        return info;
    }

    public static void UseSwaggerUIAndAddApiVersionEndPointBuilder(this IApplicationBuilder app, IApiVersionDescriptionProvider provider)
    {
        app.UseSwaggerUI(c =>
        {
            // Build a swagger endpoint for each discovered API version
            foreach (var description in provider.ApiVersionDescriptions)
            {
                c.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
            }
        });
    }
}

public void Apply(OpenApiOperation operation, OperationFilterContext context)
{
    if (operation.Parameters == null)
    {
        return;
    }

    foreach (var parameter in operation.Parameters)
    {
        var description = context.ApiDescription
            .ParameterDescriptions
            .First(p => p.Name == parameter.Name);
        var routeInfo = description.RouteInfo;

        if (parameter.Description == null)
        {
            parameter.Description = description.ModelMetadata?.Description;
        }

        if (routeInfo == null)
        {
            continue;
        }

        if (parameter.In != ParameterLocation.Path && parameter.Schema.Default == null)
        {
            parameter.Schema.Default = new OpenApiString(routeInfo.DefaultValue.ToString());
        }

        parameter.Required |= !routeInfo.IsOptional;
    }
}

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

        services.AddApiVersioningAndExplorer();

        services.AddSwaggerGeneration();
    }



    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApiVersionDescriptionProvider provider)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseSwagger();
        app.UseSwaggerUIAndAddApiVersionEndPointBuilder(provider);
        app.UseMvc();
    }
}