Merge pull request #35391 from dotnet/main

Author: guardrex

aspnetcore/client-side/bundling-and-minification.md

@@ -4,7 +4,7 @@ author: wadepickett
 description: Learn how to optimize static resources in an ASP.NET Core web application by applying bundling and minification techniques.
 ms.author: wpickett
 ms.custom: mvc
-ms.date: 03/14/2021
+ms.date: 05/08/2025
 uid: client-side/bundling-and-minification
 ---
 # Bundle and minify static assets in ASP.NET Core
@@ -21,11 +21,11 @@ Bundling and minification primarily improve the first page request load time. On
 
 ### Bundling
 
-Bundling combines multiple files into a single file. Bundling reduces the number of server requests that are necessary to render a web asset, such as a web page. You can create any number of individual bundles specifically for CSS, JavaScript, etc. Fewer files mean fewer HTTP requests from the browser to the server or from the service providing your application. This results in improved first page load performance.
+Bundling combines multiple files into a single file. Bundling reduces the number of server requests necessary to render a web asset, such as a web page. You can create any number of individual bundles specifically for CSS, JavaScript, etc. Fewer files mean fewer HTTP requests from the browser to the server or from the service providing your application. This results in improved first page load performance.
 
 ### Minification
 
-Minification removes unnecessary characters from code without altering functionality. The result is a significant size reduction in requested assets (such as CSS, images, and JavaScript files). Common side effects of minification include shortening variable names to one character and removing comments and unnecessary whitespace.
+Minification removes unnecessary characters from code without altering functionality. The result is a significant size reduction in requested assets (such as CSS, images, and JavaScript files). Common effects of minification include shortening variable names to one character and removing comments and unnecessary whitespace.
 
 Consider the following JavaScript function:
 
@@ -72,9 +72,7 @@ The test app used to generate the figures in the preceding table demonstrates ty
 
 ## Choose a bundling and minification strategy
 
-ASP.NET Core is compatible with WebOptimizer, an open-source bundling and minification solution. For set up instructions and sample projects, see [WebOptimizer](https://github.com/ligershark/WebOptimizer). ASP.NET Core doesn't provide a native bundling and minification solution.
-
-Third-party tools, such as [Gulp](https://gulpjs.com) and [Webpack](https://webpack.js.org), provide workflow automation for bundling and minification, as well as linting and image optimization. By using bundling and minification, the minified files are created prior to the app's deployment. Bundling and minifying before deployment provides the advantage of reduced server load. However, it's important to recognize that bundling and minification increases build complexity and only works with static files.
+ASP.NET Core doesn't provide a native bundling and minification solution. Third-party tools, such as [Gulp](https://gulpjs.com) and [Webpack](https://webpack.js.org), provide workflow automation for bundling and minification, as well as linting and image optimization. Bundling and minifying before deployment provides the advantage of reduced server load. However, bundling and minification increase build complexity and only work with static files.
 
 ## Environment-based bundling and minification
 

aspnetcore/fundamentals/minimal-apis/responses.md

@@ -97,7 +97,7 @@ The following method does not compile, because `TypedResults.Ok` and `TypedResul
 
 :::code language="csharp" source="~/tutorials/min-web-api/samples/7.x/todo/Program.cs" id="snippet_111":::
 
-To use `TypedResults`, the return type must be fully declared, which when asynchronous requires the `Task<>` wrapper. Using `TypedResults` is more verbose, but that's the trade-off for having the type information be statically available and thus capable of self-describing to OpenAPI:
+To use `TypedResults`, the return type must be fully declared; when the method is asynchronous, the declaration requires wrapping the return type in a `Task<>`. Using `TypedResults` is more verbose, but that's the trade-off for having the type information be statically available and thus capable of self-describing to OpenAPI:
 
 :::code language="csharp" source="~/tutorials/min-web-api/samples/7.x/todo/Program.cs" id="snippet_1b":::
 

aspnetcore/fundamentals/openapi/using-openapi-documents.md

@@ -25,6 +25,18 @@ The `Swashbuckle.AspNetCore.SwaggerUi` package provides a bundle of Swagger UI's
 
 As a security best practice on limiting information disclosure, ***OpenAPI user interfaces (Swagger UI, ReDoc, Scalar) should only be enabled in development environments.*** For example, see [Swagger OAuth 2.0 configuration](https://swagger.io/docs/open-source-tools/swagger-ui/usage/oauth2/).
 
+Launch the app and navigate to `https://localhost:<port>/swagger` to view the Swagger UI.
+
+To automatically launch the app at the Swagger UI URL using the `https` profile of `Properties/launchSettings.json`:
+
+* Confirm that `launchBrowser` is enabled (`true`).
+* Set the `launchUrl` to `swagger`.
+
+```json
+"launchBrowser": true,
+"launchUrl": "swagger",
+```
+
 ## Use Scalar for interactive API documentation
 
 [Scalar](https://scalar.com/) is an open-source interactive document UI for OpenAPI. Scalar can integrate with the OpenAPI endpoint provided by ASP.NET Core. To configure Scalar, install the `Scalar.AspNetCore` package.
@@ -33,6 +45,16 @@ As a security best practice on limiting information disclosure, ***OpenAPI user
 
 Launch the app and navigate to `https://localhost:<port>/scalar/v1` to view the Scalar UI.
 
+To automatically launch the app at the Scalar UI URL using the `https` profile of `Properties/launchSettings.json`:
+
+* Confirm that `launchBrowser` is enabled (`true`).
+* Set the `launchUrl` to `scalar/v1`.
+
+```json
+"launchBrowser": true,
+"launchUrl": "scalar/v1",
+```
+
 ## Lint generated OpenAPI documents with Spectral
 
 [Spectral](https://stoplight.io/open-source/spectral) is an open-source OpenAPI document linter. Spectral can be incorporated into an app build to verify the quality of generated OpenAPI documents. Install Spectral according to the [package installation directions](https://github.com/stoplightio/spectral#-installation).

aspnetcore/performance/caching/hybrid.md

@@ -86,7 +86,7 @@ Notice that the inline interpolated string syntax (`$"..."` in the preceding exa
 
 * Keys can be restricted to valid maximum lengths. For example, the default `HybridCache` implementation (via `AddHybridCache(...)`) restricts keys to 1024 characters by default. That number is configurable via `HybridCacheOptions.MaximumKeyLength`, with longer keys bypassing the cache mechanisms to prevent saturation.
 * Keys must be valid Unicode sequences. If invalid Unicode sequences are passed, the behavior is undefined.
-* When using an out-of-process secondary cache such as `IDistributedCache`, the specific backend implementation may impose additional restrictions. As a hypothetical example, a particular backend might use case-insensitive key logic. The default `HybridCache` (via `AddHybridCache(...)`) detects this scenario to prevent confusion attacks, however it may still result in conflicting keys becoming overwritten or evicted sooner than expected.
+* When using an out-of-process secondary cache such as `IDistributedCache`, the backend implementation may impose additional restrictions. As a hypothetical example, a particular backend might use case-insensitive key logic. The default `HybridCache` (via `AddHybridCache(...)`) detects this scenario to prevent confusion attacks or alias attacks (using bitwise string equality).  However, this scenario might still result in conflicting keys becoming overwritten or evicted sooner than expected.
 
 ### The alternative `GetOrCreateAsync` overload
 
@@ -117,7 +117,16 @@ Set tags when calling `GetOrCreateAsync`, as shown in the following example:
 
 Remove all entries for a specified tag by calling <xref:Microsoft.Extensions.Caching.Hybrid.HybridCache.RemoveByTagAsync%2A> with the tag value. An overload lets you specify a collection of tag values.
 
-When an entry is removed, it is removed from both the primary and secondary caches.
+Neither `IMemoryCache` nor `IDistributedCache` has direct support for the concept of tags, so tag-based invalidation is a *logical* operation only. It does not actively remove values from either local or distributed cache. Instead, it ensures that when receiving data with such tags, the data will be treated as a cache-miss from both the local and remote cache. The values will expire from `IMemoryCache` and `IDistributedCache` in the usual way based on the configured lifetime.
+
+## Removing all cache entries
+
+The asterisk tag (`*`) is reserved as a wildcard and is disallowed against individual values. Calling `RemoveByTagAsync("*")` has the effect of invalidating *all* `HybridCache` data, even data that does not have any tags. As with individual tags, this is a *logical* operation, and individual values continue to exist until they expire naturally. Glob-style matches are not supported. For example, you can't use `RemoveByTagAsync("foo*")` to remove everything starting with `foo`.
+
+### Additional tag considerations
+
+* The system doesn't limit the number of tags you can use, but large sets of tags might negatively impact performance.
+* Tags can't be empty, just whitespace, or the reserved value `*`.
 
 ## Options
 

aspnetcore/test/integration-tests.md

@@ -16,7 +16,7 @@ Integration tests ensure that an app's components function correctly at a level
 
 :::moniker range=">= aspnetcore-10.0"
 
-This article assumes a basic understanding of unit tests. If unfamiliar with test concepts, see the [Unit Testing in .NET Core and .NET Standard](/dotnet/core/testing/) article and its linked content.
+This article assumes a basic understanding of unit tests. If unfamiliar with test concepts, see the [Testing in .NET](/dotnet/core/testing/) article and its linked content.
 
 [View or download sample code](https://github.com/dotnet/AspNetCore.Docs.Samples/tree/main/test/integration-tests/10.x/IntegrationTestsSample) ([how to download](xref:index#how-to-download-a-sample))
 
@@ -325,4 +325,4 @@ The SUT's database context is registered in `Program.cs`. The test app's `builde
 [!INCLUDE[](~/test/integration-tests/includes/integration-tests5.md)]
 [!INCLUDE[](~/test/integration-tests/includes/integration-tests7.md)]
 [!INCLUDE[](~/test/integration-tests/includes/integration-tests8.md)]
-[!INCLUDE[](~/test/integration-tests/includes/integration-tests9.md)]
+[!INCLUDE[](~/test/integration-tests/includes/integration-tests9.md)]

aspnetcore/test/troubleshoot.md

@@ -4,7 +4,7 @@ author: tdykstra
 description: Understand and troubleshoot warnings and errors with ASP.NET Core projects.
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 07/10/2019
+ms.date: 5/2/2025
 uid: test/troubleshoot
 ---
 # Troubleshoot and debug ASP.NET Core projects
@@ -77,87 +77,9 @@ If an app is capable of responding to requests, you can obtain the following dat
 
 Place the following [middleware](xref:fundamentals/middleware/index#create-a-middleware-pipeline-with-iapplicationbuilder) code at the beginning of the `Startup.Configure` method's request processing pipeline. The environment is checked before the middleware is run to ensure that the code is only executed in the Development environment.
 
-To obtain the environment, use either of the following approaches:
-
-* Inject the `IHostingEnvironment` into the `Startup.Configure` method and check the environment with the local variable. The following sample code demonstrates this approach.
-
-* Assign the environment to a property in the `Startup` class. Check the environment using the property (for example, `if (Environment.IsDevelopment())`).
-
-```csharp
-public void Configure(IApplicationBuilder app, IHostingEnvironment env, 
-    IConfiguration config)
-{
-    if (env.IsDevelopment())
-    {
-        app.Run(async (context) =>
-        {
-            var sb = new StringBuilder();
-            var nl = System.Environment.NewLine;
-            var rule = string.Concat(nl, new string('-', 40), nl);
-            var authSchemeProvider = app.ApplicationServices
-                .GetRequiredService<IAuthenticationSchemeProvider>();
-
-            sb.Append($"Request{rule}");
-            sb.Append($"{DateTimeOffset.Now}{nl}");
-            sb.Append($"{context.Request.Method} {context.Request.Path}{nl}");
-            sb.Append($"Scheme: {context.Request.Scheme}{nl}");
-            sb.Append($"Host: {context.Request.Headers["Host"]}{nl}");
-            sb.Append($"PathBase: {context.Request.PathBase.Value}{nl}");
-            sb.Append($"Path: {context.Request.Path.Value}{nl}");
-            sb.Append($"Query: {context.Request.QueryString.Value}{nl}{nl}");
-
-            sb.Append($"Connection{rule}");
-            sb.Append($"RemoteIp: {context.Connection.RemoteIpAddress}{nl}");
-            sb.Append($"RemotePort: {context.Connection.RemotePort}{nl}");
-            sb.Append($"LocalIp: {context.Connection.LocalIpAddress}{nl}");
-            sb.Append($"LocalPort: {context.Connection.LocalPort}{nl}");
-            sb.Append($"ClientCert: {context.Connection.ClientCertificate}{nl}{nl}");
-
-            sb.Append($"Identity{rule}");
-            sb.Append($"User: {context.User.Identity.Name}{nl}");
-            var scheme = await authSchemeProvider
-                .GetSchemeAsync(IISDefaults.AuthenticationScheme);
-            sb.Append($"DisplayName: {scheme?.DisplayName}{nl}{nl}");
-
-            sb.Append($"Headers{rule}");
-            foreach (var header in context.Request.Headers)
-            {
-                sb.Append($"{header.Key}: {header.Value}{nl}");
-            }
-            sb.Append(nl);
-
-            sb.Append($"WebSockets{rule}");
-            if (context.Features.Get<IHttpUpgradeFeature>() != null)
-            {
-                sb.Append($"Status: Enabled{nl}{nl}");
-            }
-            else
-            {
-                sb.Append($"Status: Disabled{nl}{nl}");
-            }
-
-            sb.Append($"Configuration{rule}");
-            foreach (var pair in config.AsEnumerable())
-            {
-                sb.Append($"{pair.Path}: {pair.Value}{nl}");
-            }
-            sb.Append(nl);
-
-            sb.Append($"Environment Variables{rule}");
-            var vars = System.Environment.GetEnvironmentVariables();
-            foreach (var key in vars.Keys.Cast<string>().OrderBy(key => key, 
-                StringComparer.OrdinalIgnoreCase))
-            {
-                var value = vars[key];
-                sb.Append($"{key}: {value}{nl}");
-            }
-
-            context.Response.ContentType = "text/plain";
-            await context.Response.WriteAsync(sb.ToString());
-        });
-    }
-}
-```
+Get the environment from the `Environment` property of `WebApplication`. For example, `if (app.Environment.IsDevelopment())` as in the following sample code.
+
+:::code language="csharp" source="~/test/troubleshoot/code/9.x/Program.cs" highlight="13-85":::
 
 ## Debug ASP.NET Core apps