Update to .NET 6 / VS 2022 (#27379)

docs/architecture/blazor-for-web-forms-developers/app-startup.md

@@ -3,15 +3,15 @@ title: App startup
 description: Learn how to define the startup logic for your app.
 author: csharpfritz
 ms.author: jefritz
-ms.date: 11/20/2020
+ms.date: 12/2/2021
 ---
 # App startup
 
 Applications that are written for ASP.NET typically have a `global.asax.cs` file that defines the `Application_Start` event that controls which services are configured and made available for both HTML rendering and .NET processing. This chapter looks at how things are slightly different with ASP.NET Core and Blazor Server.
 
 ## Application_Start and Web Forms
 
-The default web forms `Application_Start` method has grown in purpose over years to handle many configuration tasks.  A fresh web forms project with the default template in Visual Studio 2019 now contains the following configuration logic:
+The default web forms `Application_Start` method has grown in purpose over years to handle many configuration tasks.  A fresh web forms project with the default template in Visual Studio 2022 now contains the following configuration logic:
 
 - `RouteConfig` - Application URL routing
 - `BundleConfig` - CSS and JavaScript bundling and minification
@@ -22,72 +22,76 @@ With ASP.NET Core and Blazor, these methods are either simplified and consolidat
 
 ## Blazor Server Startup Structure
 
-Blazor Server applications reside on top of an ASP.NET Core 3.0 or later version.  ASP.NET Core web applications are configured through a pair of methods in the `Startup.cs` class on the root folder of the application.  The Startup class's default content is listed below
+Blazor Server applications reside on top of an ASP.NET Core 3.0 or later version.  ASP.NET Core web applications are configured using a builder defined in *Program.cs* and optionally a `Startup` class defined in *Startup.cs*. Starting in .NET 6, the default choice is to set up the app in a single *Program.cs* file (but using a `Startup` class remains supported).
+
+In *Program.cs*, you configure the app's required services by adding them to the built-in services container and then set up the app's HTTP request pipeline.
 
 ```csharp
-public class Startup
+using BlazorApp3.Areas.Identity;
+using BlazorApp3.Data;
+using Microsoft.AspNetCore.Components.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container.
+var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
+builder.Services.AddDbContext<ApplicationDbContext>(options =>
+    options.UseSqlServer(connectionString));
+builder.Services.AddDatabaseDeveloperPageExceptionFilter();
+builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
+    .AddEntityFrameworkStores<ApplicationDbContext>();
+builder.Services.AddRazorPages();
+builder.Services.AddServerSideBlazor();
+builder.Services.AddScoped<AuthenticationStateProvider, RevalidatingIdentityAuthenticationStateProvider<IdentityUser>>();
+builder.Services.AddSingleton<WeatherForecastService>();
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (app.Environment.IsDevelopment())
 {
-  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.
-  // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
-  public void ConfigureServices(IServiceCollection services)
-  {
-    services.AddRazorPages();
-    services.AddServerSideBlazor();
-    services.AddSingleton<WeatherForecastService>();
-  }
-
-  // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
-  public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
-  {
-    if (env.IsDevelopment())
-    {
-      app.UseDeveloperExceptionPage();
-    }
-    else
-    {
-      app.UseExceptionHandler("/Error");
-      // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
-      app.UseHsts();
-    }
-
-    app.UseHttpsRedirection();
-    app.UseStaticFiles();
-
-    app.UseRouting();
-
-    app.UseEndpoints(endpoints =>
-    {
-      endpoints.MapBlazorHub();
-      endpoints.MapFallbackToPage("/_Host");
-   });
-  }
- }
-```
+    app.UseMigrationsEndPoint();
+}
+else
+{
+    app.UseExceptionHandler("/Error");
+    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
+    app.UseHsts();
+}
+
+app.UseHttpsRedirection();
+
+app.UseStaticFiles();
 
-Like the rest of ASP.NET Core, the Startup class is created with dependency injection principles.  The `IConfiguration` is provided to the constructor and stashed in a public property for later access during configuration.
+app.UseRouting();
+
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapBlazorHub();
+app.MapFallbackToPage("/_Host");
+
+app.Run();
+
+```
 
-The `ConfigureServices` method introduced in ASP.NET Core allows for the various ASP.NET Core framework services to be configured for the framework's built-in dependency injection container.  The various `services.Add*` methods add services that enable features such as authentication, razor pages, MVC controller routing, SignalR, and Blazor Server interactions among many others.  This method was not needed in web forms, as the parsing and handling of the ASPX, ASCX, ASHX, and ASMX files were defined by referencing ASP.NET in the web.config configuration file.  More information about dependency injection in ASP.NET Core is available in the [online documentation](/aspnet/core/fundamentals/dependency-injection).
+The various `services.Add*` methods add services that enable features such as authentication, razor pages, MVC controller routing, SignalR, and Blazor Server interactions among many others.  This method was not needed in web forms, as the parsing and handling of the ASPX, ASCX, ASHX, and ASMX files were defined by referencing ASP.NET in the web.config configuration file.  More information about dependency injection in ASP.NET Core is available in the [online documentation](/aspnet/core/fundamentals/dependency-injection).
 
-The `Configure` method introduces the concept of the HTTP pipeline to ASP.NET Core.  In this method, we declare from top to bottom the [Middleware](middleware.md) that will handle every request sent to our application. Most of these features in the default configuration were scattered across the web forms configuration files and are now in one place for ease of reference.
+The `app.Use*` methods define the HTTP pipeline for ASP.NET Core apps.  With these calls, we declare from top to bottom the [Middleware](middleware.md) that will handle every request sent to our application. Most of these features in the default configuration were scattered across the web forms configuration files and are now in one place for ease of reference.
 
 No longer is the configuration of the custom error page placed in a `web.config` file, but now is configured to always be shown if the application environment is not labeled `Development`.  Additionally, ASP.NET Core applications are now configured to serve secure pages with TLS by default with the `UseHttpsRedirection` method call.
 
 Next, an unexpected configuration method is listed to `UseStaticFiles`.  In ASP.NET Core, support for requests for static files (like JavaScript, CSS, and image files) must be explicitly enabled, and only files in the app's *wwwroot* folder are publicly addressable by default.
 
 The next line is the first that replicates one of the configuration options from web forms: `UseRouting`.  This method adds the ASP.NET Core router to the pipeline and it can be either configured here or in the individual files that it can consider routing to.  More information about routing configuration can be found in the [Routing section](pages-routing-layouts.md).
 
-The final statement in this method defines the endpoints that ASP.NET Core is listening on.  These routes are the web accessible locations that you can access on the web server and receive some content handled by .NET and returned to you.  The first entry, `MapBlazorHub` configures a SignalR hub for use in providing the real-time and persistent connection to the server where the state and rendering of Blazor components is handled.  The `MapFallbackToPage` method call indicates the web-accessible location of the page that starts the Blazor application and also configures the application to handle deep-linking requests from the client-side.  You will see this feature at work if you open a browser and navigate directly to Blazor handled route in your application, such as `/counter` in the default project template. The request gets handled by the *_Host.cshtml* fallback page, which then runs the Blazor router and renders the counter page.
+The final `app.Map*` statements define the endpoints that ASP.NET Core is listening on.  These routes are the web accessible locations that you can access on the web server and receive some content handled by .NET and returned to you.  The first entry, `MapBlazorHub` configures a SignalR hub for use in providing the real-time and persistent connection to the server where the state and rendering of Blazor components is handled.  The `MapFallbackToPage` method call indicates the web-accessible location of the page that starts the Blazor application and also configures the application to handle deep-linking requests from the client-side.  You will see this feature at work if you open a browser and navigate directly to Blazor handled route in your application, such as `/counter` in the default project template. The request gets handled by the *_Host.cshtml* fallback page, which then runs the Blazor router and renders the counter page.
 
 ## Upgrading the BundleConfig Process
 
-Technologies for bundling assets like CSS stylesheets and JavaScript files have evolved significantly, with other technologies providing quickly evolving tools and techniques for managing these resources.  To this end, we recommend using a Node command-line tool such as Grunt / Gulp / WebPack to package your static assets.
+Technologies for bundling assets like CSS stylesheets and JavaScript files have changed significantly, with other technologies providing quickly evolving tools and techniques for managing these resources.  To this end, we recommend using a Node command-line tool such as Grunt / Gulp / WebPack to package your static assets.
 
 The Grunt, Gulp, and WebPack command-line tools and their associated configurations can be added to your application and ASP.NET Core will quietly ignore those files during the application build process.  You can add a call to run their tasks by adding a `Target` inside your project file with syntax similar to the following that would trigger a gulp script and the `min` target inside that script
 

docs/architecture/blazor-for-web-forms-developers/architecture-comparison.md

@@ -4,7 +4,7 @@ description: Learn how the architectures of ASP.NET Web Forms and Blazor compare
 author: danroth27
 ms.author: daroth
 no-loc: [Blazor]
-ms.date: 11/20/2020
+ms.date: 12/2/2021
 ---
 # Architecture comparison of ASP.NET Web Forms and Blazor
 

docs/architecture/blazor-for-web-forms-developers/components.md

@@ -4,7 +4,7 @@ description: Learn how to build reusable UI components with Blazor and how they
 author: danroth27
 ms.author: daroth
 no-loc: [Blazor]
-ms.date: 09/18/2019
+ms.date: 12/2/2021
 ---
 # Build reusable UI components with Blazor
 

docs/architecture/blazor-for-web-forms-developers/data.md

@@ -4,7 +4,7 @@ description: Learn how to access and handle data in ASP.NET Web Forms and Blazor
 author: csharpfritz    
 ms.author: jefritz
 no-loc: [Blazor]
-ms.date: 11/20/2020
+ms.date: 12/2/2021
 ---
 
 # Work with data

docs/architecture/blazor-for-web-forms-developers/forms-validation.md

@@ -4,7 +4,7 @@ description: Learn how to build forms with client-side validation in Blazor.
 author: danroth27
 ms.author: daroth
 no-loc: [Blazor, "Blazor WebAssembly"]
-ms.date: 09/19/2019
+ms.date: 12/2/2021
 ---
 # Forms and validation
 

docs/architecture/blazor-for-web-forms-developers/hosting-models.md

@@ -4,7 +4,7 @@ description: Learn the different ways to host a Blazor app, including in the bro
 author: danroth27
 ms.author: daroth
 no-loc: [Blazor, WebAssembly]
-ms.date: 11/20/2020
+ms.date: 12/2/2021
 ---
 # Blazor app hosting models
 

docs/architecture/blazor-for-web-forms-developers/index.md

@@ -4,11 +4,11 @@ description: Learn how to build full-stack web apps with .NET using Blazor and .
 author: danroth27
 ms.author: daroth
 no-loc: [Blazor, WebAssembly]
-ms.date: 11/15/2021
+ms.date: 12/2/2021
 ---
 # Blazor for ASP.NET Web Forms Developers
 
-![Screenshot that shows the Serverless Apps e-book cover.](./media/index/blazor-for-aspnet-web-forms-developers.png)
+![Blazor for ASP.NET Web Forms Developers  e-book cover.](./media/index/blazor-for-aspnet-web-forms-developers.png)
 
 > DOWNLOAD available at: <https://aka.ms/blazor-ebook>
 

docs/architecture/blazor-for-web-forms-developers/introduction.md

@@ -4,7 +4,7 @@ description: An introduction to Blazor and writing full-stack web apps with .NET
 author: danroth27
 ms.author: daroth
 no-loc: [Blazor, WebAssembly]
-ms.date: 11/20/2020
+ms.date: 12/2/2021
 ---
 # An introduction to Blazor for ASP.NET Web Forms developers
 
@@ -25,13 +25,13 @@ When .NET and ASP.NET Web Forms first shipped, the platform ecosystem looked muc
 
 Most modern web frameworks are now also open-source, which has a number of benefits. Users aren't beheld to a single project owner to fix bugs and add features. Open-source projects provide improved transparency on development progress and upcoming changes. Open-source projects enjoy contributions from an entire community, and they foster a supportive open-source ecosystem. Despite the risks of open-source, many consumers and contributors have found suitable mitigations that enable them to enjoy the benefits of an open-source ecosystem in a safe and reasonable way. Examples of such mitigations include contributor license agreements, friendly licenses, pedigree scans, and supporting foundations.
 
-The .NET community has embraced both cross-platform support and open-source. .NET Core is an open-source and cross-platform implementation of .NET that runs on a plethora of platforms, including Windows, macOS, and various Linux distributions. Xamarin provides Mono, an open-source version of .NET. Mono runs on Android, iOS, and a variety of other form factors, including watches and smart TVs. Microsoft has released [.NET 5](https://devblogs.microsoft.com/dotnet/announcing-net-5-0/) that reconciled .NET Core and Mono into "a single .NET runtime and framework that can be used everywhere and that has uniform runtime behaviors and developer experiences."
+The .NET community has embraced both cross-platform support and open-source. .NET Core is an open-source and cross-platform implementation of .NET that runs on a plethora of platforms, including Windows, macOS, and various Linux distributions. Xamarin provides Mono, an open-source version of .NET. Mono runs on Android, iOS, and a variety of other form factors, including watches and smart TVs. In 2020, Microsoft released [.NET 5](https://devblogs.microsoft.com/dotnet/announcing-net-5-0/) that reconciled .NET Core and Mono into "a single .NET runtime and framework that can be used everywhere and that has uniform runtime behaviors and developer experiences."
 
-Will ASP.NET Web Forms benefit from the move to open-source and cross-platform support? The answer, unfortunately, is no, or at least not to the same extent as the rest of the platform. The .NET team [recently made it clear](https://devblogs.microsoft.com/dotnet/net-core-is-the-future-of-net/) that ASP.NET Web Forms won't be ported to .NET Core or .NET 5. Why is that?
+Will ASP.NET Web Forms benefit from the move to open-source and cross-platform support? The answer, unfortunately, is no, or at least not to the same extent as the rest of the platform. The .NET team [made it clear](https://devblogs.microsoft.com/dotnet/net-core-is-the-future-of-net/) that ASP.NET Web Forms won't be ported to .NET Core or .NET 6. Why is that?
 
 There were efforts in the early days of .NET Core to port ASP.NET Web Forms. The number of breaking changes required were found to be too drastic. There's also an admission here that even for Microsoft, there's a limit to the number of web frameworks that it can support simultaneously. Perhaps someone in the community will take up the cause of creating an open-source and cross-platform version of ASP.NET Web Forms. The [source code for ASP.NET Web Forms](https://github.com/microsoft/referencesource) has been made available publicly in reference form. But for the time being, it seems ASP.NET Web Forms will remain Windows-only and without an open-source contribution model. If cross-platform support or open-source become important for your scenarios, then you'll need to look for something new.
 
-Does this mean ASP.NET Web Forms is *dead* and should no longer be used? Of course not! As long as the .NET Framework ships as part of Windows, ASP.NET Web Forms will be a supported framework. For many Web Forms developers, the lack of cross-platform and open-source support is a non-issue. If you don't have a requirement for cross-platform support, open-source, or any of the other new features in .NET Core or .NET 5, then sticking with ASP.NET Web Forms on Windows is fine. ASP.NET Web Forms will continue to be a productive way to write web apps for many years to come.
+Does this mean ASP.NET Web Forms is *dead* and should no longer be used? Of course not! As long as the .NET Framework ships as part of Windows, ASP.NET Web Forms will be a supported framework. For many Web Forms developers, the lack of cross-platform and open-source support is a non-issue. If you don't have a requirement for cross-platform support, open-source, or any of the other new features in .NET Core or .NET 6, then sticking with ASP.NET Web Forms on Windows is fine. ASP.NET Web Forms will continue to be a productive way to write web apps for many years to come.
 
 But there's another trend worth considering, and that's the shift to the client.
 
@@ -47,7 +47,7 @@ But bridging two different platforms and ecosystems (.NET and JavaScript) comes
 
 In 2015, the major browser vendors joined forces in a W3C Community Group to create a new open web standard called WebAssembly. WebAssembly is a byte code for the Web. If you can compile your code to WebAssembly, it can then run on any browser on any platform at near native speed. Initial efforts focused on C/C++. The result was a dramatic demonstration of running native 3D graphics engines directly in the browser without plugins. WebAssembly has since been standardized and implemented by all major browsers.
 
-Work on running .NET on WebAssembly was announced in late 2017 and released in 2020, including support from .NET 5. The ability to run .NET code directly in the browser enables full-stack web development with .NET.
+Work on running .NET on WebAssembly was announced in late 2017 and released in 2020, including support in .NET 5 and beyond. The ability to run .NET code directly in the browser enables full-stack web development with .NET.
 
 ## Blazor: full-stack web development with .NET
 

docs/architecture/blazor-for-web-forms-developers/middleware.md

@@ -4,7 +4,7 @@ description: Learn about handling HTTP requests with modules, handlers, and midd
 author: danroth27
 ms.author: daroth
 no-loc: [Blazor]
-ms.date: 10/11/2019
+ms.date: 12/2/2021
 ---
 # Modules, handlers, and middleware