Blazor WASM linker to trimmer (#19849)

Author: guardrex

aspnetcore/blazor/components/class-libraries.md

@@ -167,5 +167,16 @@ Upload the package to NuGet using the [`dotnet nuget push`](/dotnet/core/tools/d
 
 ## Additional resources
 
+::: moniker range=">= aspnetcore-5.0"
+
+* <xref:razor-pages/ui-class>
+* [Add an XML Intermediate Language (IL) Trimmer configuration file to a library](xref:blazor/host-and-deploy/configure-trimmer)
+
+::: moniker-end
+
+::: moniker range="< aspnetcore-5.0"
+
 * <xref:razor-pages/ui-class>
-* [Add an XML linker configuration file to a library](xref:blazor/host-and-deploy/configure-linker#add-an-xml-linker-configuration-file-to-a-library)
+* [Add an XML Intermediate Language (IL) Linker configuration file to a library](xref:blazor/host-and-deploy/configure-linker#add-an-xml-linker-configuration-file-to-a-library)
+
+::: moniker-end

aspnetcore/blazor/globalization-localization.md

@@ -58,7 +58,23 @@ Blazor WebAssembly apps set the culture using the user's [language preference](h
 
 To explicitly configure the culture, set <xref:System.Globalization.CultureInfo.DefaultThreadCurrentCulture?displayProperty=nameWithType> and <xref:System.Globalization.CultureInfo.DefaultThreadCurrentUICulture?displayProperty=nameWithType> in `Program.Main`.
 
-By default, Blazor's linker configuration for Blazor WebAssembly apps strips out internationalization information except for locales explicitly requested. For more information and guidance on controlling the linker's behavior, see <xref:blazor/host-and-deploy/configure-linker#configure-the-linker-for-internationalization>.
+::: moniker range=">= aspnetcore-5.0"
+
+By default, Blazor WebAssembly carries globalization resources required to display values, such as dates and currency, in the user's culture. If the app doesn't require localization, you may configure the app to support the invariant culture, which is based on the `en-US` culture:
+
+```xml
+<PropertyGroup>
+  <InvariantGlobalization>true</InvariantGlobalization>
+</PropertyGroup>
+```
+
+::: moniker-end
+
+::: moniker range="< aspnetcore-5.0"
+
+By default, the Intermediate Language (IL) Linker configuration for Blazor WebAssembly apps strips out internationalization information except for locales explicitly requested. For more information, see <xref:blazor/host-and-deploy/configure-linker#configure-the-linker-for-internationalization>.
+
+::: moniker-end
 
 While the culture that Blazor selects by default might be sufficient for most users, consider offering a way for users to specify their preferred locale. For a Blazor WebAssembly sample app with a culture picker, see the [`LocSample`](https://github.com/pranavkm/LocSample) localization sample app.
 

aspnetcore/blazor/host-and-deploy/configure-linker.md

@@ -2,7 +2,7 @@
 title: Configure the Linker for ASP.NET Core Blazor
 author: guardrex
 description: Learn how to control the Intermediate Language (IL) Linker when building a Blazor app.
-monikerRange: '>= aspnetcore-3.1'
+monikerRange: '>= aspnetcore-3.1 <= aspnetcore-5.0'
 ms.author: riande
 ms.custom: mvc
 ms.date: 05/19/2020
@@ -15,7 +15,7 @@ By [Luke Latham](https://github.com/guardrex)
 
 Blazor WebAssembly performs [Intermediate Language (IL)](/dotnet/standard/managed-code#intermediate-language--execution) linking during a build to trim unnecessary IL from the app's output assemblies. The linker is disabled when building in Debug configuration. Apps must build in Release configuration to enable the linker. We recommend building in Release when deploying your Blazor WebAssembly apps. 
 
-Linking an app optimizes for size but may have detrimental effects. Apps that use reflection or related dynamic features may break when trimmed because the linker doesn't know about this dynamic behavior and can't determine in general which types are required for reflection at runtime. To trim such apps, the linker must be informed about any types required by reflection in the code and in packages or frameworks that the app depends on. 
+Linking an app optimizes for size but may have detrimental effects. Apps that use reflection or related dynamic features may break when trimmed because the linker doesn't know about this dynamic behavior and can't determine in general which types are required for reflection at runtime. To trim such apps, the linker must be informed about any types required by reflection in the code and in packages or frameworks that the app depends on.
 
 To ensure the trimmed app works correctly once deployed, it's important to test Release builds of the app frequently while developing.
 

aspnetcore/blazor/host-and-deploy/configure-trimmer.md

@@ -0,0 +1,33 @@
+---
+title: Configure the Trimmer for ASP.NET Core Blazor
+author: guardrex
+description: Learn how to control the Intermediate Language (IL) Linker (Trimmer) when building a Blazor app.
+monikerRange: '>= aspnetcore-5.0'
+ms.author: riande
+ms.custom: mvc
+ms.date: 09/14/2020
+no-loc: ["ASP.NET Core Identity", cookie, Cookie, Blazor, "Blazor Server", "Blazor WebAssembly", "Identity", "Let's Encrypt", Razor, SignalR]
+uid: blazor/host-and-deploy/configure-trimmer
+---
+# Configure the Trimmer for ASP.NET Core Blazor
+
+By [Pranav Krishnamoorthy](https://github.com/pranavkm)
+
+Blazor WebAssembly performs [Intermediate Language (IL)](/dotnet/standard/managed-code#intermediate-language--execution) trimming to reduce the size of the published output.
+
+Trimming an app optimizes for size but may have detrimental effects. Apps that use reflection or related dynamic features may break when trimmed because the trimmer doesn't know about dynamic behavior and can't determine in general which types are required for reflection at runtime. To trim such apps, the trimmer must be informed about any types required by reflection in the code and in packages or frameworks that the app depends on.
+
+To ensure the trimmed app works correctly once deployed, it's important to test published output frequently while developing.
+
+Trimming for .NET apps can be disabled by setting the `PublishTrimmed` MSBuild property to `false` in the app's project file:
+
+```xml
+<PropertyGroup>
+  <PublishTrimmed>false</PublishTrimmed>
+</PropertyGroup>
+```
+
+## Additional resources
+
+* [Trim self-contained deployments and executables](/dotnet/core/deploying/trim-self-contained)
+* <xref:blazor/webassembly-performance-best-practices#intermediate-language-il-trimming>

aspnetcore/blazor/host-and-deploy/webassembly.md

@@ -692,10 +692,22 @@ The `--urls` argument sets the IP addresses or host addresses with ports and pro
   --urls=http://127.0.0.1:0
   ```
 
+::: moniker range=">= aspnetcore-5.0"
+
+## Configure the Trimmer
+
+Blazor performs Intermediate Language (IL) trimming on each Release build to remove unnecessary IL from the output assemblies. For more information, see <xref:blazor/host-and-deploy/configure-trimmer>.
+
+::: moniker-end
+
+::: moniker range="< aspnetcore-5.0"
+
 ## Configure the Linker
 
 Blazor performs Intermediate Language (IL) linking on each Release build to remove unnecessary IL from the output assemblies. For more information, see <xref:blazor/host-and-deploy/configure-linker>.
 
+::: moniker-end
+
 ## Custom boot resource loading
 
 A Blazor WebAssembly app can be initialized with the `loadBootResource` function to override the built-in boot resource loading mechanism. Use `loadBootResource` for the following scenarios:

aspnetcore/blazor/index.md

@@ -115,10 +115,22 @@ When a Blazor WebAssembly app is built and run in a browser:
 
 The size of the published app, its *payload size*, is a critical performance factor for an app's useability. A large app takes a relatively long time to download to a browser, which diminishes the user experience. Blazor WebAssembly optimizes payload size to reduce download times:
 
+::: moniker range=">= aspnetcore-5.0"
+
+* Unused code is stripped out of the app when it's published by the [Intermediate Language (IL) Trimmer](xref:blazor/host-and-deploy/configure-trimmer).
+* HTTP responses are compressed.
+* The .NET runtime and assemblies are cached in the browser.
+
+::: moniker-end
+
+::: moniker range="< aspnetcore-5.0"
+
 * Unused code is stripped out of the app when it's published by the [Intermediate Language (IL) Linker](xref:blazor/host-and-deploy/configure-linker).
 * HTTP responses are compressed.
 * The .NET runtime and assemblies are cached in the browser.
 
+::: moniker-end
+
 ## Blazor Server
 
 Blazor decouples component rendering logic from how UI updates are applied. Blazor Server provides support for hosting Razor components on the server in an ASP.NET Core app. UI updates are handled over a [SignalR](xref:signalr/introduction) connection.

aspnetcore/blazor/webassembly-performance-best-practices.md

@@ -125,9 +125,21 @@ Blazor WebAssembly offers two additional versions of <xref:Microsoft.JSInterop.I
 
 ## Reduce app size
 
+::: moniker range=">= aspnetcore-5.0"
+
+### Intermediate Language (IL) trimming
+
+[Trimming unused assemblies from a Blazor WebAssembly app](xref:blazor/host-and-deploy/configure-trimmer) reduces the app's size by removing unused code in the app's binaries. By default, the Trimmer is executed when publishing an application. To benefit from trimming, publish the app for deployment using the [`dotnet publish`](/dotnet/core/tools/dotnet-publish) command with the [-c|--configuration](/dotnet/core/tools/dotnet-publish#options) option set to `Release`:
+
+::: moniker-end
+
+::: moniker range="< aspnetcore-5.0"
+
 ### Intermediate Language (IL) linking
 
-[Linking a Blazor WebAssembly app](xref:blazor/host-and-deploy/configure-linker) reduces the app's size by trimming unused code in the app's binaries. By default, the linker is only enabled when building in `Release` configuration. To benefit from this, publish the app for deployment using the [`dotnet publish`](/dotnet/core/tools/dotnet-publish) command with the [-c|--configuration](/dotnet/core/tools/dotnet-publish#options) option set to `Release`:
+[Linking a Blazor WebAssembly app](xref:blazor/host-and-deploy/configure-linker) reduces the app's size by trimming unused code in the app's binaries. By default, the Intermediate Language (IL) Linker is only enabled when building in `Release` configuration. To benefit from this, publish the app for deployment using the [`dotnet publish`](/dotnet/core/tools/dotnet-publish) command with the [-c|--configuration](/dotnet/core/tools/dotnet-publish#options) option set to `Release`:
+
+::: moniker-end
 
 ```dotnetcli
 dotnet publish -c Release
@@ -157,13 +169,14 @@ Blazor WebAssembly's runtime includes the following .NET features that can be di
 
 ::: moniker range=">= aspnetcore-5.0"
 
-* By default, Blazor WebAssembly carries globalization resources required to display values, such as dates and currency, in the user's culture. If the app doesn't require localization, you may configure the app to support the invariant culture, which is based on the `en-US` culture:
+* By default, Blazor WebAssembly carries globalization resources required to display values, such as dates and currency, in the user's culture. If the app doesn't require localization, you may [configure the app to support the invariant culture](xref:blazor/globalization-localization), which is based on the `en-US` culture:
 
   ```xml
   <PropertyGroup>
     <InvariantGlobalization>true</InvariantGlobalization>
   </PropertyGroup>
   ```
+
 ::: moniker-end
 
 ::: moniker range="< aspnetcore-5.0"

aspnetcore/toc.yml

@@ -447,6 +447,8 @@
               uid: blazor/host-and-deploy/server
             - name: Configure the Linker
               uid: blazor/host-and-deploy/configure-linker
+            - name: Configure the Trimmer
+              uid: blazor/host-and-deploy/configure-trimmer
         - name: Blazor Server and EF Core
           uid: blazor/blazor-server-ef-core
         - name: Advanced scenarios