ASP.NET Core 6 - no Swagger output

Question

In .NET 6, I fiddled with the new startup class somehow I do not get a swagger json outputted (so the swagger ui fails). Probably there is somewhere a mistake but as far as I understand this should be it.

 WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

builder.Configuration.SetBasePath(Directory.GetCurrentDirectory());
builder.Configuration.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
builder.Configuration.AddEnvironmentVariables();
builder.Configuration.AddJsonFile("Settings/LogSettings.json", optional: true, reloadOnChange: true);
builder.Configuration.AddJsonFile("Settings/HealthCheckSettings.json", optional: true, reloadOnChange: true);
builder.Configuration.AddJsonFile("Settings/AcmeSettings.json", optional: true, reloadOnChange: true);
builder.Configuration.AddJsonFile("Settings/DbConnectionSettings.json", optional: true, reloadOnChange: true);
builder.Configuration.AddJsonFile("Settings/ApiSettings.json", optional: true, reloadOnChange: true);
builder.Configuration.AddIniFile("appsettings.ini", optional: true, reloadOnChange: true);
builder.Configuration.AddXmlFile("apssettings.xml", optional: true, reloadOnChange: true);
builder.Configuration.AddIniFile("Settings/appsettings.ini", optional: true, reloadOnChange: true);
builder.Configuration.AddXmlFile("Settings/appsettings.xml", optional: true, reloadOnChange: true);

LoggerProviderCollection Providers = new();
var outputTemplate = "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{Method}{NewLine}{Message}{NewLine}in method {MemberName} at {FilePath}:{LineNumber}{NewLine}{Exception}{NewLine}";
Serilog.Formatting.Display.MessageTemplateTextFormatter tf = new(outputTemplate, CultureInfo.InvariantCulture);

ColumnOptions columnOptions = new();
columnOptions.Store.Remove(StandardColumn.MessageTemplate);
columnOptions.Store.Remove(StandardColumn.Properties);
columnOptions.Store.Add(StandardColumn.LogEvent);
columnOptions.DisableTriggers = true;
columnOptions.ClusteredColumnstoreIndex = false;
columnOptions.Store.Remove(StandardColumn.Id);
columnOptions.TimeStamp.ConvertToUtc = true;
columnOptions.AdditionalColumns = new Collection<SqlColumn>
{
    new SqlColumn { ColumnName = "RequestPath", PropertyName = "RequestPath", DataType = SqlDbType.NVarChar, DataLength = 1000 },
    new SqlColumn { ColumnName = "SourceContext", PropertyName = "SourceContext", DataType = SqlDbType.NVarChar, DataLength = 255 },
    new SqlColumn { ColumnName = "ActionName", PropertyName = "ActionName", DataType = SqlDbType.NVarChar, DataLength = 255 },

    new SqlColumn { ColumnName = "ThreadId", PropertyName = "ThreadId", DataType = SqlDbType.NVarChar, DataLength = 255 },
    new SqlColumn { ColumnName = "RequestId", PropertyName = "RequestId", DataType = SqlDbType.NVarChar, DataLength = 255 },
    new SqlColumn { ColumnName = "ActionId", PropertyName = "ActionId", DataType = SqlDbType.NVarChar, DataLength = 255 },

    new SqlColumn { ColumnName = "MachineName", PropertyName = "MachineName", DataType = SqlDbType.NVarChar, DataLength = 255 },
    new SqlColumn { ColumnName = "MemoryUsage", PropertyName = "MemoryUsage", DataType = SqlDbType.NVarChar, DataLength = 16 }
};

Serilog.Core.Logger logger = new LoggerConfiguration()
    .ReadFrom.Configuration(builder.Configuration)
    .MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Warning)
    .WriteTo.Providers(Providers)
    .Enrich.WithExceptionDetails(new DestructuringOptionsBuilder()
        .WithDefaultDestructurers()
        .WithDestructurers(new[] { new DbUpdateExceptionDestructurer() }))
    .WriteTo.Map("Tag", builder.Configuration["Serilog:Sql:DefaultTable"], (name, wt) => wt.MSSqlServer(
        connectionString: builder.Configuration.GetConnectionString(builder.Configuration["Serilog:Sql:ConnectionStringName"]),
        sinkOptions: new Serilog.Sinks.MSSqlServer.MSSqlServerSinkOptions
        {
            TableName = builder.Configuration["Serilog:Sql:Table"] + name,
            SchemaName = builder.Configuration["Serilog:Sql:Schema"],
            BatchPeriod = new TimeSpan(0, 0, 5),
            AutoCreateSqlTable = true,
            BatchPostingLimit = 50,
            EagerlyEmitFirstEvent = true
        },
        columnOptions: columnOptions
        ))
    .Enrich.WithAssemblyName()
    .Enrich.WithAssemblyVersion()
    .CreateLogger();

Serilog.Debugging.SelfLog.Enable(msg => Debug.WriteLine(msg));
builder.Logging.AddSerilog(logger);
builder.Services.AddLogging();
builder.WebHost.UseSerilog();

builder.Services.AddResponseCompression();
builder.Services.AddResponseCompression(options =>
{
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
    options.MimeTypes =
        ResponseCompressionDefaults.MimeTypes.Concat(
            new[] { "image/svg+xml" });
});
builder.Services.Configure<BrotliCompressionProviderOptions>(options =>
{
    options.Level = CompressionLevel.Fastest;
});
builder.Services.Configure<GzipCompressionProviderOptions>(options =>
{
    options.Level = CompressionLevel.Fastest;
});

builder.Services.AddHttpContextAccessor();

Acme.Sys.Health.RegisterHealthChecks.Register(builder.Services, builder.Configuration);

builder.Services.AddDistributedMemoryCache();

builder.Services.AddSignalR(hubOptions =>
{
    hubOptions.EnableDetailedErrors = true;
    hubOptions.KeepAliveInterval = System.TimeSpan.FromMinutes(1);
});

builder.Services.Configure<IpRateLimitOptions>(builder.Configuration.GetSection("IpRateLimiting"));
builder.Services.Configure<IpRateLimitPolicies>(builder.Configuration.GetSection("IpRateLimitPolicies"));
builder.Services.AddDistributedRateLimiting<AsyncKeyLockProcessingStrategy>();
builder.Services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(builder =>
       builder
        .SetIsOriginAllowed(_ => true)
        .AllowAnyHeader()
        .AllowAnyMethod()
        .AllowCredentials()
        .WithExposedHeaders("*")
    );
});

builder.Services.AddEndpointsApiExplorer();
Uri contactUrl = new("http://www.Acme.nl");
var xfile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var filePath = Path.Combine(AppContext.BaseDirectory, xfile);
builder.Services.AddSwaggerGen(options =>
{
    options.SwaggerDoc("v1", new OpenApiInfo
    {
        Version = "7.44.00",
        Title = "Acme7",
        Description = "REST Service Acme 7",
        TermsOfService = contactUrl,
        Contact = new OpenApiContact()
        {
            Name = "Acme Support",
            Email = "support@Acme.nl",
            Url = contactUrl
        }
    });


    options.SwaggerDoc("Acme6", new OpenApiInfo
    {
        Version = "3.999.99",
        Title = "Acme3",
        Description = "REST Service Acme 3",
        TermsOfService = contactUrl,
        Contact = new OpenApiContact()
        {
            Name = "Acme Support 3",
            Email = "support@Acme.nl",
            Url = contactUrl
        }
    });

    options.ResolveConflictingActions(apiDescriptions => apiDescriptions.First());
    options.DocumentFilter<TagOrderByNameDocumentFilter>();
    options.ExampleFilters();
    options.OperationFilter<AddResponseHeadersFilter>(); // [SwaggerResponseHeader]
    options.EnableAnnotations();
    options.CustomSchemaIds(x => x.FullName);
    options.SchemaFilter<AttributeSchemaFilter>();
    options.IncludeXmlComments(filePath);
    options.DocInclusionPredicate((docName, apiDesc) =>
    {
        if (!apiDesc.TryGetMethodInfo(out MethodInfo methodInfo)) return false;
        var versions = methodInfo.DeclaringType
            .GetCustomAttributes(true)
            .OfType<ApiExplorerSettingsAttribute>();
        return (docName == "v1" && string.IsNullOrEmpty(apiDesc.GroupName)) || versions.Any(v => string.Equals(v.GroupName, docName, StringComparison.CurrentCultureIgnoreCase));
    });

    options.OperationFilter<AppendAuthorizeToSummaryOperationFilter>();

    options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Description = "JWT Authorization header using the Bearer scheme. Enter 'Bearer' [space] and then your token in the text input below.",
        Name = "Authorization",
        In = ParameterLocation.Header,
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer"
    });
    options.AddSecurityRequirement(new OpenApiSecurityRequirement()
                    {
                        {
                            new OpenApiSecurityScheme
                            {
                                Reference = new OpenApiReference
                                {
                                    Type = ReferenceType.SecurityScheme,
                                    Id = "Bearer"
                                },
                                Scheme = "OAuth2",
                                Name = "Bearer",
                                In = ParameterLocation.Header
                            },
                            new List<string>()
                        }
                    });

});
builder.Services.AddSwaggerExamplesFromAssemblies(Assembly.GetEntryAssembly());
builder.WebHost.UseWebRoot(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot"));

Acme.Identity.Authentication.Settings _Acme_identity_authentication_settings = new();
builder.Configuration.GetSection(Acme.Identity.Authentication.Settings.SettingsPath).Bind(_Acme_identity_authentication_settings);

builder.Services.AddAuthentication(o =>
{
    o.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    o.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = _Acme_identity_authentication_settings.Issuer,
        ValidAudience = _Acme_identity_authentication_settings.Audience,
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_Acme_identity_authentication_settings.AccessTokenKey))
    };

    options.Events = new JwtBearerEvents
    {
        OnMessageReceived = context =>
        {
            var accessToken = context.Request.Query["access_token"];
            var path = context.HttpContext.Request.Path;
            if (!string.IsNullOrEmpty(accessToken) && path.StartsWithSegments("/hubs", System.StringComparison.OrdinalIgnoreCase))
            {
                // Read the token out of the query string
                context.Token = accessToken;
            }
            return Task.CompletedTask;
        },
        OnAuthenticationFailed = context =>
        {
            if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
            {
                context.Response.Headers.Add("Token-Expired", "true");
            }
            return Task.CompletedTask;
        }
    };
});

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("User", configurePolicy: policy =>
    {
            policy.RequireAssertion(context => context.User.IsInRole("USER"));
    });

    options.AddPolicy("Superman", policy =>
    {
            policy.RequireAssertion(context =>
                context.User.IsInRole("SUPERMAN") &&
                context.User.HasClaim(c => (c.Type == "IsSuperMan")));
    });

    options.AddPolicy("SuperUser", policy =>
    {
            policy.RequireAssertion(context =>
                context.User.IsInRole("SUPERUSER"));
    });
});

// ------------------------------------------------------------------------------------------------
// add services: Acme specific services
// ------------------------------------------------------------------------------------------------
AcmeCompany.Common.RegisterServices.Register(builder.Services);
builder.Services.Configure<AcmeCompany.Common.Domain.DomainLookupServiceOptions>
  (builder.Configuration.GetSection(nameof(AcmeCompany.Common.Domain.DomainLookupServiceOptions)));

builder.Services.Configure<AcmeCompany.Common.Dapper.DapperOptions>(d =>
    d.ConnectionString = builder.Configuration.GetConnectionString("Acme7"));

Acme.Sys.Dapper.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Sys.Db.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Org.Customer.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Sys.Realtime.RegisterServices.Register(builder.Services);
Acme.Sys.License.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Identity.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Sys.Job.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Sys.Localization.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Org.Employee.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Configuration.RegisterServices.Register(builder.Services, builder.Configuration);
Acme.Sys.Email.RegisterServices.Register(builder.Services, builder.Configuration);


// ------------------------------------------------------------------------------------------------
// add services: Automapper
// ------------------------------------------------------------------------------------------------
builder.Services.AddAutoMapper(typeof(Program));

var mapperConfig = new MapperConfiguration(cfg =>
{
    cfg.AddProfile(new Acme.Sys.Job.MappingProfile());
    cfg.AddProfile(new Acme.Org.Customer.MappingProfile());
    cfg.AddProfile(new Acme.Sys.Localization.MappingProfile());
    cfg.AddProfile(new Acme.Org.Country.MappingProfile());
    cfg.AddProfile(new Acme.Identity.MappingProfile());
    cfg.AddProfile(new Acme.Identity.Account.MappingProfile());
    cfg.AddProfile(new Acme.Configuration.MappingProfile());
});

mapperConfig.AssertConfigurationIsValid();

mapperConfig.CompileMappings();

IMapper mapper = mapperConfig.CreateMapper();
builder.Services.AddSingleton(mapper);

// ------------------------------------------------------------------------------------------------
// add services: Controllers
// ------------------------------------------------------------------------------------------------
builder.Services.AddControllers(mvcoptions => { })
.ConfigureApiBehaviorOptions(apibehaviour =>
{
    apibehaviour.InvalidModelStateResponseFactory = context =>
    {
        var result = new BadRequestObjectResult(context.ModelState);
        result.ContentTypes.Add(MediaTypeNames.Application.Json);
        result.ContentTypes.Add(MediaTypeNames.Application.Xml);
        return result;
    };
})

.AddJsonOptions(options =>
{
    options.JsonSerializerOptions.PropertyNamingPolicy = null;
    options.JsonSerializerOptions.ReferenceHandler = null;
    options.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
});

builder.Services.AddSingleton<IUserIdProvider, CustomUserIdProvider>();

builder.Services.AddControllers(options => options.Filters.Add<CacheModificationDateActionFilter>());
builder.Services.AddControllers(options => options.Filters.Add<ValidateModelActionFilter>());

builder.Services.Configure<ApiBehaviorOptions>(opts => opts.SuppressModelStateInvalidFilter = true);

WebApplication app = builder.Build();

app.UseSerilogRequestLogging(options =>
    //options.GetLevel = (httpContext, elapsed, ex) => LogEventLevel.Debug;
    options.EnrichDiagnosticContext = (diagnosticContext, httpContext) =>
    {
        diagnosticContext.Set("RequestHost", httpContext.Request.Host.Value);
        diagnosticContext.Set("RequestScheme", httpContext.Request.Scheme);
    });

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/api/error/error-local-development");
    app.UseHsts();
}
else
{
    app.UseExceptionHandler("/api/error/error");
}

app.UseRouting();

app.UseCors();

app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint(url: "/swagger/v1/swagger.json", name: "Acme 7 Service");
    c.SwaggerEndpoint(url: "/swagger/Acme3/swagger.json", name: "Acme 3");
});

app.UseSerilogRequestLogging(options =>
    //options.GetLevel = (httpContext, elapsed, ex) => LogEventLevel.Debug;
    options.EnrichDiagnosticContext = (diagnosticContext, httpContext) =>
    {
        diagnosticContext.Set("RequestHost", httpContext.Request.Host.Value);
        diagnosticContext.Set("RequestScheme", httpContext.Request.Scheme);
    });

app.UseIpRateLimiting();

if (app.Configuration.GetValue<bool>("Acme:Https") == true)
{
    app.UseHttpsRedirection();
}

app.UseResponseCompression();
app.UseStaticFiles();
app.UseAuthentication();
app.UseAuthorization();

var supportedCultures = new[]
{
                new CultureInfo("en"),
                new CultureInfo("nl")
            };

var options = new RequestLocalizationOptions
{
    DefaultRequestCulture = new RequestCulture("en"),
    SupportedCultures = supportedCultures,
    SupportedUICultures = supportedCultures
};

options.AddInitialRequestCultureProvider(new CustomRequestCultureProvider(async context =>
{
    var currentCulture = "en"; 
    if (context.Request.HttpContext.User.Identity.IsAuthenticated)
    {
        var _applicationUserService = context.Request.HttpContext.RequestServices.GetService<IApplicationUserService>();
        var applicationUser = await _applicationUserService.GetApplicationUserAsync(context.Request.HttpContext.User);
        currentCulture = applicationUser.LanguageId;
    }
    else
    {
        //  var arguments = context.ActionArguments;
        //                foreach (var argument in arguments)
        //                {  if argument.name = "credentials" { get the value of the object LanguageId if not null convert to string } }
    }
    var requestCulture = new ProviderCultureResult(currentCulture);
    return await Task.FromResult(requestCulture);
}));

app.UseRequestLocalization(options);

/*
app.Use(async (context, next) =>
{
    Endpoint endpoint = context.GetEndpoint();

    var rgx = "/(api|hubs)/.*";
    if (System.Text.RegularExpressions.Regex.IsMatch(context.Request.Path.Value, rgx) && endpoint == null)
    {
        context.Response.StatusCode = StatusCodes.Status404NotFound;
        await context.Response.WriteAsync("Endpoint is not defined");
    }
    else
    {
        // throws: object reference not set to an instance of an object: source HealthChecks .UI
        await next();
    }
});*/
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
    endpoints.MapHub<ResultHub>("/hubs/resultHub");
    Acme.Sys.Health.HealthCheckEndPoints.RegisterHealthCheckEndPoints(app.Configuration, endpoints);
});

app.UseSpa(spa => spa.Options.SourcePath = "wwwroot");
app.Run();

Answer 1

Your code is missing a call to UseSwagger , which takes care of producing the JSON output you're missing. You can call it before UseSwaggerUI , like this:

app.UseSwagger();
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint(url: "/swagger/v1/swagger.json", name: "Acme 7 Service");
    c.SwaggerEndpoint(url: "/swagger/Acme3/swagger.json", name: "Acme 3");
});

See Add and configure Swagger middleware for more information about the Swagger middleware setup.