public static void Snippet1(WebApplicationBuilder builder)
{
// <snippet_ServicesDefault>
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// </snippet_ServicesDefault>
var app = builder.Build();
// <snippet_MiddlewareJsonV2>
app.UseSwagger(options =>
{
options.SerializeAsV2 = true;
});
// </snippet_MiddlewareJsonV2>
// <snippet_MiddlewareRoutePrefix>
app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/swagger/v1/swagger.json", "v1");
options.RoutePrefix = string.Empty;
});
// </snippet_MiddlewareRoutePrefix>
}
public static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
builder.Services.AddRazorPages();
var isBuilder = builder.Services.AddIdentityServer(options =>
{
options.Events.RaiseErrorEvents = true;
options.Events.RaiseInformationEvents = true;
options.Events.RaiseFailureEvents = true;
options.Events.RaiseSuccessEvents = true;
// see https://docs.duendesoftware.com/identityserver/v6/fundamentals/resources/
options.EmitStaticAudienceClaim = true;
})
.AddTestUsers(TestUsers.Users);
// in-memory, code config
isBuilder.AddInMemoryIdentityResources(Config.IdentityResources);
isBuilder.AddInMemoryApiScopes(Config.ApiScopes);
isBuilder.AddInMemoryClients(Config.Clients);
builder.Services.AddAuthentication()
.AddGoogle(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
// register your IdentityServer with Google at https://console.developers.google.com
// enable the Google+ API
// set the redirect URI to https://localhost:5001/signin-google
options.ClientId = "copy client ID from Google here";
options.ClientSecret = "copy client secret from Google here";
});
return(builder.Build());
}
internal static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
builder.Services.AddRazorPages()
.AddRazorRuntimeCompilation();
builder.ConfigureIdentityServer();
builder.AddExternalIdentityProviders();
builder.AddAdminFeatures();
// var apiKey = builder.Configuration["HoneyCombApiKey"];
// var dataset = "IdentityServerDev";
//
// builder.Services.AddOpenTelemetryTracing(builder =>
// {
// builder
// //.AddConsoleExporter()
// .AddSource(IdentityServerConstants.Tracing.ServiceName)
// .SetResourceBuilder(
// ResourceBuilder.CreateDefault()
// .AddService("IdentityServerHost.EF"))
// //.SetSampler(new AlwaysOnSampler())
// .AddHttpClientInstrumentation()
// .AddAspNetCoreInstrumentation()
// .AddSqlClientInstrumentation()
// .AddOtlpExporter(option =>
// {
// option.Endpoint = new Uri("https://api.honeycomb.io");
// option.Headers = $"x-honeycomb-team={apiKey},x-honeycomb-dataset={dataset}";
// });
// });
return(builder.Build());
}
public static WebApplication GetHost(this WebApplicationBuilder builder)
{
var host = builder.Build();
host.AddEventuousLogs();
return(host);
}
public async Task DoesNotHangOnConnectionCloseRequest()
{
var config = new ConfigurationBuilder().AddInMemoryCollection(
new Dictionary <string, string> {
{ "server.urls", "http://localhost:8791" }
}).Build();
var builder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(app =>
{
app.Run(async context =>
{
var connection = context.Connection;
await context.Response.WriteAsync("hello, world");
});
});
using (var app = builder.Build().Start())
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Connection.Clear();
client.DefaultRequestHeaders.Connection.Add("close");
var response = await client.GetAsync("http://localhost:8791/");
response.EnsureSuccessStatusCode();
}
}
public async Task RegisterAddresses_Success(string addressInput, string[] testUrls)
{
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>
{
{ "server.urls", addressInput }
})
.Build();
var applicationBuilder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(ConfigureEchoAddress);
using (var app = applicationBuilder.Build().Start())
{
using (var client = new HttpClient())
{
foreach (var testUrl in testUrls)
{
var responseText = await client.GetStringAsync(testUrl);
Assert.Equal(testUrl, responseText);
}
}
}
}
public async Task LargeDownload()
{
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>
{
{ "server.urls", "http://localhost:8792/" }
})
.Build();
var applicationBuilder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(app =>
{
app.Run(async context =>
{
var bytes = new byte[1024];
for (int i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)i;
}
context.Response.ContentLength = bytes.Length * 1024;
for (int i = 0; i < 1024; i++)
{
await context.Response.Body.WriteAsync(bytes, 0, bytes.Length);
}
});
});
using (var app = applicationBuilder.Build().Start())
{
using (var client = new HttpClient())
{
var response = await client.GetAsync("http://localhost:8792/");
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStreamAsync();
// Read the full response body
var total = 0;
var bytes = new byte[1024];
var count = await responseBody.ReadAsync(bytes, 0, bytes.Length);
while (count > 0)
{
for (int i = 0; i < count; i++)
{
Assert.Equal(total % 256, bytes[i]);
total++;
}
count = await responseBody.ReadAsync(bytes, 0, bytes.Length);
}
}
}
}
public static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
builder.Services.AddRazorPages();
builder.Services.AddControllers();
// cookie policy to deal with temporary browser incompatibilities
builder.Services.AddSameSiteCookiePolicy();
builder.Services.AddIdentityServer(options =>
{
options.Events.RaiseErrorEvents = true;
options.Events.RaiseFailureEvents = true;
options.Events.RaiseInformationEvents = true;
options.Events.RaiseSuccessEvents = true;
// options.KeyManagement.SigningAlgorithms = new[]
// {
// new SigningAlgorithmOptions("RS256")
// {
// UseX509Certificate = true
// }
// };
})
.AddInMemoryApiScopes(Config.ApiScopes)
.AddInMemoryIdentityResources(Config.IdentityResources)
.AddInMemoryApiResources(Config.ApiResources)
.AddInMemoryClients(Config.Clients)
.AddTestUsers(TestUsers.Users);
builder.Services.AddAuthentication()
.AddLocalApi()
.AddOpenIdConnect("Google", "Sign-in with Google", options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.ForwardSignOut = IdentityServerConstants.DefaultCookieAuthenticationScheme;
options.Authority = "https://accounts.google.com/";
options.ClientId = "708778530804-rhu8gc4kged3he14tbmonhmhe7a43hlp.apps.googleusercontent.com";
options.CallbackPath = "/signin-google";
options.Scope.Add("email");
});
// add CORS policy for non-IdentityServer endpoints
builder.Services.AddCors(options =>
{
options.AddPolicy("allow_all",
policy => { policy.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod(); });
});
// demo versions (never use in production)
builder.Services.AddTransient <IRedirectUriValidator, DemoRedirectValidator>();
builder.Services.AddTransient <ICorsPolicyService, DemoCorsPolicy>();
return(builder.Build());
}
static async Task RunDFrameControllerAsync(WebApplicationBuilder appBuilder, DFrameControllerOptions options, Action <WebHostBuilderContext, DFrameControllerOptions> configureOptions)
{
appBuilder.WebHost.ConfigureServices((WebHostBuilderContext ctx, IServiceCollection services) =>
{
services.AddGrpc();
services.AddMagicOnion(x =>
{
// Should use same options between DFrame.Controller(this) and DFrame.Worker
x.SerializerOptions = MessagePackSerializerOptions.Standard;
});
services.AddSingleton <IMagicOnionLogger, MagicOnionLogToLogger>();
services.AddRazorPages()
.ConfigureApplicationPartManager(manager =>
{
// import libraries razor pages
var assembly = typeof(DFrameControllerWebApplicationBuilderExtensions).Assembly;
var assemblyPart = new CompiledRazorAssemblyPart(assembly);
manager.ApplicationParts.Add(assemblyPart);
});
services.AddServerSideBlazor();
// DFrame Options
services.TryAddSingleton <DFrameControllerExecutionEngine>();
services.TryAddSingleton <DFrameControllerLogBuffer>();
services.AddSingleton <ILoggerProvider, DFrameControllerLoggerProvider>();
services.AddScoped <LocalStorageAccessor>();
configureOptions(ctx, options);
services.AddSingleton(options);
// If user sets custom provdier, use it.
services.TryAddSingleton <IExecutionResultHistoryProvider, InMemoryExecutionResultHistoryProvider>();
services.AddMessagePipe();
});
var app = appBuilder.Build();
app.UseStaticFiles();
app.UseRouting();
app.MapBlazorHub();
app.MapFallbackToPage("/_Host");
app.MapMagicOnionService();
DisplayConfiguration(app);
if (!options.DisableRestApi)
{
RestApi.RegisterRestApi(app);
}
await app.RunAsync();
}
public static WebApplication CreateWebApplication(string[] args)
{
IConfiguration configuration = CreateConfiguration(args);
WebApplicationBuilder builder = CreateWebApplicationBuilder(args, configuration);
WebApplication app = builder.Build();
ConfigureApp(app);
return(app);
}
internal static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
builder.Services.AddRazorPages()
.AddRazorRuntimeCompilation();
builder.Services.AddControllers();
// cookie policy to deal with temporary browser incompatibilities
builder.Services.AddSameSiteCookiePolicy();
builder.ConfigureIdentityServer();
builder.AddExternalIdentityProviders();
builder.AddAdminFeatures();
builder.Services.AddLocalApiAuthentication(principal =>
{
principal.Identities.First().AddClaim(new Claim("additional_claim", "additional_value"));
return(Task.FromResult(principal));
});
// var apiKey = builder.Configuration["HoneyCombApiKey"];
// var dataset = "IdentityServerDev";
//
// builder.Services.AddOpenTelemetryTracing(builder =>
// {
// builder
// .AddSource(IdentityServerConstants.Tracing.Basic)
// .AddSource(IdentityServerConstants.Tracing.Cache)
// .AddSource(IdentityServerConstants.Tracing.Services)
// .AddSource(IdentityServerConstants.Tracing.Stores)
// .AddSource(IdentityServerConstants.Tracing.Validation)
//
// .SetResourceBuilder(
// ResourceBuilder.CreateDefault()
// .AddService("IdentityServerHost.Main"))
//
// //.SetSampler(new AlwaysOnSampler())
// .AddHttpClientInstrumentation()
// .AddAspNetCoreInstrumentation()
// .AddSqlClientInstrumentation()
// //.AddConsoleExporter()
// .AddOtlpExporter(option =>
// {
// option.Endpoint = new Uri("https://api.honeycomb.io");
// option.Headers = $"x-honeycomb-team={apiKey},x-honeycomb-dataset={dataset}";
// });
// });
return(builder.Build());
}
public async Task LargeUpload()
{
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>
{
{ "server.urls", "http://localhost:8791/" }
})
.Build();
var applicationBuilder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(app =>
{
app.Run(async context =>
{
// Read the full request body
var total = 0;
var bytes = new byte[1024];
var count = await context.Request.Body.ReadAsync(bytes, 0, bytes.Length);
while (count > 0)
{
for (int i = 0; i < count; i++)
{
Assert.Equal(total % 256, bytes[i]);
total++;
}
count = await context.Request.Body.ReadAsync(bytes, 0, bytes.Length);
}
await context.Response.WriteAsync(total.ToString(CultureInfo.InvariantCulture));
});
});
using (var app = applicationBuilder.Build().Start())
{
using (var client = new HttpClient())
{
var bytes = new byte[1024 * 1024];
for (int i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)i;
}
var response = await client.PostAsync("http://localhost:8791/", new ByteArrayContent(bytes));
response.EnsureSuccessStatusCode();
var sizeString = await response.Content.ReadAsStringAsync();
Assert.Equal(sizeString, bytes.Length.ToString(CultureInfo.InvariantCulture));
}
}
}
public static void UseStatusCodePagesRedirect(WebApplicationBuilder builder)
{
// <snippet_UseStatusCodePagesRedirect>
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseStatusCodePagesWithRedirects("/StatusCode/{0}");
// </snippet_UseStatusCodePagesRedirect>
}
public static void UseStatusCodePagesContent(WebApplicationBuilder builder)
{
// <snippet_UseStatusCodePagesContent>
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
// using static System.Net.Mime.MediaTypeNames;
app.UseStatusCodePages(Text.Plain, "Status Code Page: {0}");
// </snippet_UseStatusCodePagesContent>
}
public static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
// uncomment if you want to add a UI
//builder.Services.AddRazorPages();
builder.Services.AddIdentityServer(options =>
{
// https://docs.duendesoftware.com/identityserver/v6/fundamentals/resources/api_scopes#authorization-based-on-scopes
options.EmitStaticAudienceClaim = true;
})
.AddInMemoryIdentityResources(Config.IdentityResources)
.AddInMemoryApiScopes(Config.ApiScopes)
.AddInMemoryClients(Config.Clients);
return(builder.Build());
}
public static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
builder.Services.AddRazorPages();
builder.Services.AddControllers();
// add BFF services and server-side session management
builder.Services.AddBff()
.AddRemoteApis()
.AddServerSideSessions();
builder.Services.AddAuthentication(options =>
{
options.DefaultScheme = "cookie";
options.DefaultChallengeScheme = "oidc";
options.DefaultSignOutScheme = "oidc";
})
.AddCookie("cookie", options =>
{
options.Cookie.Name = "__Host-bff";
options.Cookie.SameSite = SameSiteMode.Strict;
})
.AddOpenIdConnect("oidc", options =>
{
options.Authority = "https://demo.duendesoftware.com";
options.ClientId = "interactive.confidential";
options.ClientSecret = "secret";
options.ResponseType = "code";
options.ResponseMode = "query";
options.GetClaimsFromUserInfoEndpoint = true;
options.SaveTokens = true;
options.MapInboundClaims = false;
options.Scope.Clear();
options.Scope.Add("openid");
options.Scope.Add("profile");
options.Scope.Add("api");
options.Scope.Add("offline_access");
options.TokenValidationParameters.NameClaimType = "name";
options.TokenValidationParameters.RoleClaimType = "role";
});
return(builder.Build());
}
public static void Main(string[] args)
{
// Vari esempi per usare il builder: https://docs.microsoft.com/en-us/aspnet/core/migration/50-to-60-samples
WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
Startup startup = new(builder.Configuration);
// Aggiungere i servizi per la dependency injection (metodo ConfigureServices)
startup.ConfigureServices(builder.Services);
WebApplication app = builder.Build();
// Usiamo i middleware (metodo Configure)
startup.Configure(app);
app.Run();
}
public static WebApplication App(WebApplicationBuilder builder)
{
var app = builder.Build();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.UseDefaultFiles();
app.UseStaticFiles();
app.UseSpa(spa =>
{
spa.Options.SourcePath = "wwwroot";
});
return(app);
}
public async Task IgnoreNullHeaderValues(string headerName, StringValues headerValue, string expectedValue)
{
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>
{
{ "server.urls", "http://localhost:8793/" }
})
.Build();
var hostBuilder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(app =>
{
app.Run(async context =>
{
context.Response.Headers.Add(headerName, headerValue);
await context.Response.WriteAsync("");
});
});
using (var app = hostBuilder.Build().Start())
{
using (var client = new HttpClient())
{
var response = await client.GetAsync("http://localhost:8793/");
response.EnsureSuccessStatusCode();
var headers = response.Headers;
if (expectedValue == null)
{
Assert.False(headers.Contains(headerName));
}
else
{
Assert.True(headers.Contains(headerName));
Assert.Equal(headers.GetValues(headerName).Single(), expectedValue);
}
}
}
}
private async Task TestRemoteIPAddress(string registerAddress, string requestAddress, string expectAddress, string port)
{
var config = new ConfigurationBuilder().AddInMemoryCollection(
new Dictionary <string, string> {
{ "server.urls", $"http://{registerAddress}:{port}" }
}).Build();
var builder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(app =>
{
app.Run(async context =>
{
var connection = context.Connection;
await context.Response.WriteAsync(JsonConvert.SerializeObject(new
{
RemoteIPAddress = connection.RemoteIpAddress?.ToString(),
RemotePort = connection.RemotePort,
LocalIPAddress = connection.LocalIpAddress?.ToString(),
LocalPort = connection.LocalPort,
IsLocal = connection.IsLocal
}));
});
});
using (var app = builder.Build().Start())
using (var client = new HttpClient())
{
var response = await client.GetAsync($"http://{requestAddress}:{port}/");
response.EnsureSuccessStatusCode();
var connectionFacts = await response.Content.ReadAsStringAsync();
Assert.NotEmpty(connectionFacts);
var facts = JsonConvert.DeserializeObject <JObject>(connectionFacts);
Assert.Equal(expectAddress, facts["RemoteIPAddress"].Value <string>());
Assert.NotEmpty(facts["RemotePort"].Value <string>());
Assert.True(facts["IsLocal"].Value <bool>());
}
}
public void AddSql_ConfigurationProvidedAsParameter_ApiClientsAreAddedToServiceCollection()
{
//Arrange
ApiClientConfiguration configuration = new ApiClientConfiguration
{
HttpClients = new List <HttpClient>
{
new HttpClient
{
BaseAddress = "http://localhost:8080/",
Name = "Sample",
TimeoutSeconds = 21,
Headers = new List <Header>
{
new Header
{
Name = "HeaderName",
Value = "HeaderValue"
}
}
}
}
};
//Act
_sut.Services.AddApiClient <ISampleApiClient, SampleApiClient>("Sample", configuration); //Name has to match name provided in configuration
//Assert
var app = _sut.Build();
var sampleClient = app.Services.GetService <ISampleApiClient>();
Assert.NotNull(sampleClient);
Assert.Equal(new Uri(configuration.HttpClients.First().BaseAddress), sampleClient.HttpClient.BaseAddress);
Assert.Equal(TimeSpan.FromSeconds(configuration.HttpClients.First().TimeoutSeconds.Value), sampleClient.HttpClient.Timeout);
var header = sampleClient.HttpClient.DefaultRequestHeaders.FirstOrDefault(h =>
h.Key == configuration.HttpClients.First().Headers.First().Name);
Assert.Equal(configuration.HttpClients.First().Headers.First().Value, header.Value.First());
}
public void AddSql_ConfigurationProvidedAsParameter_SqlServivesAreAddedToServiceCollection()
{
//Arrange
SqlConfiguration sqlConfiguration = new SqlConfiguration();
sqlConfiguration.ConnectionString = "ExampleConnectionString";
//Act
_sut.Services.AddSql(sqlConfiguration);
//Assert
var app = _sut.Build();
ISqlConnectionFactory?sqlConnectionFactory = app.Services.GetService <ISqlConnectionFactory>();
Assert.NotNull(sqlConnectionFactory);
Assert.Equal(sqlConfiguration.ConnectionString, sqlConnectionFactory.GetConnectionString());
}
public static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
builder.Services.AddRazorPages();
builder.Services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("DefaultConnection")));
builder.Services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
builder.Services
.AddIdentityServer(options =>
{
options.Events.RaiseErrorEvents = true;
options.Events.RaiseInformationEvents = true;
options.Events.RaiseFailureEvents = true;
options.Events.RaiseSuccessEvents = true;
// see https://docs.duendesoftware.com/identityserver/v6/fundamentals/resources/
options.EmitStaticAudienceClaim = true;
})
.AddInMemoryIdentityResources(Config.IdentityResources)
.AddInMemoryApiScopes(Config.ApiScopes)
.AddInMemoryClients(Config.Clients)
.AddAspNetIdentity <ApplicationUser>();
builder.Services.AddAuthentication()
.AddGoogle(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
// register your IdentityServer with Google at https://console.developers.google.com
// enable the Google+ API
// set the redirect URI to https://localhost:5001/signin-google
options.ClientId = "copy client ID from Google here";
options.ClientSecret = "copy client secret from Google here";
});
return(builder.Build());
}
public async Task ZeroToTenThreads(int threadCount)
{
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary<string, string>
{
{ "server.urls", "http://localhost:8790/" }
})
.Build();
var applicationBuilder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(app =>
{
var serverInfo = app.ServerFeatures.Get<IKestrelServerInformation>();
serverInfo.ThreadCount = threadCount;
app.Run(context =>
{
return context.Response.WriteAsync("Hello World");
});
});
using (var app = applicationBuilder.Build().Start())
{
using (var client = new HttpClient())
{
// Send 20 requests just to make sure we don't get any failures
var requestTasks = new List<Task<string>>();
for (int i = 0; i < 20; i++)
{
var requestTask = client.GetStringAsync("http://localhost:8790/");
requestTasks.Add(requestTask);
}
foreach (var result in await Task.WhenAll(requestTasks))
{
Assert.Equal("Hello World", result);
}
}
}
}
public static void UseStatusCodePagesInline(WebApplicationBuilder builder)
{
// <snippet_UseStatusCodePagesInline>
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseStatusCodePages(async statusCodeContext =>
{
// using static System.Net.Mime.MediaTypeNames;
statusCodeContext.HttpContext.Response.ContentType = Text.Plain;
await statusCodeContext.HttpContext.Response.WriteAsync(
$"Status Code Page: {statusCodeContext.HttpContext.Response.StatusCode}");
});
// </snippet_UseStatusCodePagesInline>
}
private async Task TestPathBase(string registerAddress, string requestAddress, string expectedPathBase, string expectedPath)
{
var config = new ConfigurationBuilder().AddInMemoryCollection(
new Dictionary <string, string> {
{ "server.urls", registerAddress }
}).Build();
var builder = new WebApplicationBuilder()
.UseConfiguration(config)
.UseServerFactory("Microsoft.AspNet.Server.Kestrel")
.Configure(app =>
{
app.Run(async context =>
{
await context.Response.WriteAsync(JsonConvert.SerializeObject(new
{
PathBase = context.Request.PathBase.Value,
Path = context.Request.Path.Value
}));
});
});
using (var app = builder.Build().Start())
{
using (var client = new HttpClient())
{
var response = await client.GetAsync(requestAddress);
response.EnsureSuccessStatusCode();
var responseText = await response.Content.ReadAsStringAsync();
Assert.NotEmpty(responseText);
var pathFacts = JsonConvert.DeserializeObject <JObject>(responseText);
Assert.Equal(expectedPathBase, pathFacts["PathBase"].Value <string>());
Assert.Equal(expectedPath, pathFacts["Path"].Value <string>());
}
}
}
public static WebApplication ConfigureServices(this WebApplicationBuilder builder)
{
builder.Services.AddRazorPages();
var isBuilder = builder.Services.AddIdentityServer(options =>
{
options.Events.RaiseErrorEvents = true;
options.Events.RaiseInformationEvents = true;
options.Events.RaiseFailureEvents = true;
options.Events.RaiseSuccessEvents = true;
options.EmitStaticAudienceClaim = true;
})
.AddTestUsers(TestUsers.Users);
// in-memory, code config
isBuilder.AddInMemoryIdentityResources(Config.IdentityResources);
isBuilder.AddInMemoryApiScopes(Config.ApiScopes);
isBuilder.AddInMemoryClients(Config.Clients);
return(builder.Build());
}
public void WebApplicationBuilderApplicationNameCanBeOverridden()
{
var assemblyName = typeof(WebApplicationTests).Assembly.GetName().Name;
var options = new WebApplicationOptions
{
ApplicationName = assemblyName
};
var builder = new WebApplicationBuilder(
options,
bootstrapBuilder =>
{
// Verify the defaults observed by the boostrap host builder we use internally to populate
// the defaults
bootstrapBuilder.ConfigureAppConfiguration((context, config) =>
{
Assert.Equal(assemblyName, context.HostingEnvironment.ApplicationName);
});
});
Assert.Equal(assemblyName, builder.Environment.ApplicationName);
builder.Host.ConfigureAppConfiguration((context, config) =>
{
Assert.Equal(assemblyName, context.HostingEnvironment.ApplicationName);
});
builder.WebHost.ConfigureAppConfiguration((context, config) =>
{
Assert.Equal(assemblyName, context.HostingEnvironment.ApplicationName);
});
var app = builder.Build();
var hostEnv = app.Services.GetRequiredService <IHostEnvironment>();
var webHostEnv = app.Services.GetRequiredService <IWebHostEnvironment>();
Assert.Equal(assemblyName, hostEnv.ApplicationName);
Assert.Equal(assemblyName, webHostEnv.ApplicationName);
}
public static void UseExceptionHandlerInline(WebApplicationBuilder builder)
{
// <snippet_UseExceptionHandlerInline>
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler(exceptionHandlerApp =>
{
exceptionHandlerApp.Run(async context =>
{
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
// using static System.Net.Mime.MediaTypeNames;
context.Response.ContentType = Text.Plain;
await context.Response.WriteAsync("An exception was thrown.");
var exceptionHandlerPathFeature =
context.Features.Get <IExceptionHandlerPathFeature>();
if (exceptionHandlerPathFeature?.Error is FileNotFoundException)
{
await context.Response.WriteAsync(" The file was not found.");
}
if (exceptionHandlerPathFeature?.Path == "/")
{
await context.Response.WriteAsync(" Page: Home.");
}
});
});
app.UseHsts();
}
// </snippet_UseExceptionHandlerInline>
}
private static void Snippet3(WebApplicationBuilder builder)
{
#region snippet_AddHttpClientHeaderPropagation
// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddHttpClient("PropagateHeaders")
.AddHeaderPropagation();
builder.Services.AddHeaderPropagation(options =>
{
options.Headers.Add("X-TraceId");
});
var app = builder.Build();
// Configure the HTTP request pipeline.
app.UseHttpsRedirection();
app.UseHeaderPropagation();
app.MapControllers();
#endregion
}
