Merge pull request #17781 from dotnet/master

Update live with master

Author: scottaddie

aspnetcore/data/ef-rp/read-related-data.md

@@ -132,6 +132,8 @@ The following code loads related data with the `Select` method:
 
 [!code-csharp[](intro/samples/cu30snapshots/6-related/Pages/Courses/IndexSelect.cshtml.cs?name=snippet_RevisedIndexMethod&highlight=6)]
 
+The preceding code doesn't return any entity types, therefore no tracking is done. For more information about the EF tracking, see [Tracking vs. No-Tracking Queries](/ef/core/querying/tracking).
+
 The `CourseViewModel`:
 
 [!code-csharp[](intro/samples/cu30snapshots/6-related/Models/SchoolViewModels/CourseViewModel.cs?name=snippet)]

aspnetcore/fundamentals/routing.md

@@ -449,6 +449,8 @@ Using a template is generally the simplest approach to routing. Constraints and
 Complex segments are processed by matching up literal delimiters from right to left in a [non-greedy](#greedy) way. For example, `[Route("/a{b}c{d}")]` is a complex segment.
 Complex segments work in a particular way that must be understood to use them successfully. The example in this section demonstrates why complex segments only really work well when the delimiter text doesn't appear inside the parameter values. Using a [regex](/dotnet/standard/base-types/regular-expressions) and then manually extracting the values is needed for more complex cases.
 
+[!INCLUDE[](~/includes/regex.md)]
+
 This is a summary of the steps that routing performs with the template `/a{b}c{d}` and the URL path `/abcd`. The `|` is used to help visualize how the algorithm works:
 
 * The first literal, right to left, is `c`. So `/abcd` is searched from right and finds `/ab|c|d`.

aspnetcore/mvc/controllers/routing.md

@@ -524,6 +524,7 @@ The `RouteTokenTransformerConvention` is registered as an option in `ConfigureSe
 
 See [MDN web docs on Slug](https://developer.mozilla.org/docs/Glossary/Slug) for the definition of Slug.
 
+[!INCLUDE[](~/includes/regex.md)]
 <a name="routing-multiple-routes-ref-label"></a>
 
 ### Multiple attribute routes

aspnetcore/mvc/controllers/routing/samples/3.x/main/StartupSlugifyParamTransformer.cs

@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using System;
 using System.Text.RegularExpressions;
 
 namespace WebMvcRouting
@@ -63,9 +64,11 @@ public string TransformOutbound(object value)
         {
             if (value == null) { return null; }
 
-            // Slugify value
             return Regex.Replace(value.ToString(),
-                                 "([a-z])([A-Z])", "$1-$2").ToLowerInvariant();
+                                 "([a-z])([A-Z])",
+                                 "$1-$2",
+                                 RegexOptions.CultureInvariant,
+                                 TimeSpan.FromMilliseconds(100)).ToLowerInvariant();
         }
     }
     #endregion

aspnetcore/mvc/views/view-compilation.md

@@ -4,20 +4,96 @@ author: rick-anderson
 description: Learn how compilation of Razor files occurs in an ASP.NET Core app.
 ms.author: riande
 ms.custom: mvc
-ms.date: 4/8/2020
+ms.date: 04/13/2020
 uid: mvc/views/view-compilation
 ---
 # Razor file compilation in ASP.NET Core
 
 By [Rick Anderson](https://twitter.com/RickAndMSFT)
 
-::: moniker range=">= aspnetcore-3.0"
+::: moniker range=">= aspnetcore-3.1"
+
+Razor files with a *.cshtml* extension are compiled at both build and publish time using the [Razor SDK](xref:razor-pages/sdk). Runtime compilation may be optionally enabled by configuring your project.
+
+## Razor compilation
+
+Build-time and publish-time compilation of Razor files is enabled by default by the Razor SDK. When enabled, runtime compilation complements build-time compilation, allowing Razor files to be updated if they're edited.
+
+## Enable runtime compilation at project creation
+
+The Razor Pages and MVC project templates include an option to enable runtime compilation when the project is created. This option is supported in ASP.NET Core 3.1 and later.
+
+# [Visual Studio](#tab/visual-studio)
+
+In the **Create a new ASP.NET Core web application** dialog:
+
+1. Select either the **Web Application** or the **Web Application (Model-View-Controller)** project template.
+1. Select the **Enable Razor runtime compilation** check box.
+
+# [.NET Core CLI](#tab/netcore-cli)
+
+Use the `-rrc` or `--razor-runtime-compilation` template option. For example, the following command creates a new Razor Pages project with runtime compilation enabled:
+
+```dotnetcli
+dotnet new webapp --razor-runtime-compilation
+```
+
+---
+
+## Enable runtime compilation in an existing project
+
+To enable runtime compilation for all environments in an existing project:
+
+1. Install the [Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation](https://www.nuget.org/packages/Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation/) NuGet package.
+1. Update the project's `Startup.ConfigureServices` method to include a call to <xref:Microsoft.Extensions.DependencyInjection.RazorRuntimeCompilationMvcBuilderExtensions.AddRazorRuntimeCompilation*>. For example:
+
+    ```csharp
+    public void ConfigureServices(IServiceCollection services)
+    {
+        services.AddRazorPages()
+            .AddRazorRuntimeCompilation();
+
+        // code omitted for brevity
+    }
+    ```
+
+## Conditionally enable runtime compilation in an existing project
+
+Runtime compilation can be enabled such that it's only available for local development. Conditionally enabling in this manner ensures that the published output:
+
+* Uses compiled views.
+* Doesn't enable file watchers in production.
+
+To enable runtime compilation only in the Development environment:
+
+1. Install the [Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation](https://www.nuget.org/packages/Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation/) NuGet package.
+1. Modify the launch profile `environmentVariables` section in *launchSettings.json*:
+    * Verify `ASPNETCORE_ENVIRONMENT` is set to `"Development"`.
+    * Set `ASPNETCORE_HOSTINGSTARTUPASSEMBLIES` to `"Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation"`.
+
+In the following example, runtime compilation is enabled in the Development environment for the `IIS Express` and `RazorPagesApp` launch profiles:
+
+[!code-json[](~/mvc/views/view-compilation/samples/3.1/launchSettings.json?highlight=15-16,24-25)]
+
+No code changes are needed in the project's `Startup` class. At runtime, ASP.NET Core searches for an [assembly-level HostingStartup attribute](xref:fundamentals/configuration/platform-specific-configuration#hostingstartup-attribute) in `Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation`. The `HostingStartup` attribute specifies the app startup code to execute. That startup code enables runtime compilation.
+
+## Additional resources
+
+* [RazorCompileOnBuild and RazorCompileOnPublish](xref:razor-pages/sdk#properties) properties.
+* <xref:razor-pages/index>
+* <xref:mvc/views/overview>
+* <xref:razor-pages/sdk>
+* See the [runtime compilation sample on GitHub](https://github.com/aspnet/samples/tree/master/samples/aspnetcore/mvc/runtimecompilation) for a sample that shows making runtime compilation work across projects.
+
+::: moniker-end
+
+::: moniker range="= aspnetcore-3.0"
 
 Razor files with a *.cshtml* extension are compiled at both build and publish time using the [Razor SDK](xref:razor-pages/sdk). Runtime compilation may be optionally enabled by configuring your application.
 
 ## Razor compilation
 
-Build- and publish-time compilation of Razor files is enabled by default by the Razor SDK. When enabled, runtime compilation complements build-time compilation, allowing Razor files to be updated if they are edited.
+Build-time and publish-time compilation of Razor files is enabled by default by the Razor SDK. When enabled, runtime compilation complements build-time compilation, allowing Razor files to be updated if they're edited.
 
 ## Runtime compilation
 
@@ -55,15 +131,15 @@ To enable runtime compilation based on the environment and configuration mode:
 
 1. Update the project's `Startup.ConfigureServices` method to include a call to `AddRazorRuntimeCompilation`. Conditionally execute `AddRazorRuntimeCompilation` such that it only runs in Debug mode when the `ASPNETCORE_ENVIRONMENT` variable is set to `Development`:
 
-  [!code-csharp[](~/mvc/views/view-compilation/sample/Startup.cs?name=snippet)]
+    [!code-csharp[](~/mvc/views/view-compilation/samples/3.0/Startup.cs?name=snippet)]
 
 ## Additional resources
 
 * [RazorCompileOnBuild and RazorCompileOnPublish](xref:razor-pages/sdk#properties) properties.
 * <xref:razor-pages/index>
 * <xref:mvc/views/overview>
 * <xref:razor-pages/sdk>
-* See the [runtimecompilation sample on GitHub](https://github.com/aspnet/samples/tree/master/samples/aspnetcore/mvc/runtimecompilation) for a sample that shows making runtime compilation work across projects.
+* See the [runtime compilation sample on GitHub](https://github.com/aspnet/samples/tree/master/samples/aspnetcore/mvc/runtimecompilation) for a sample that shows making runtime compilation work across projects.
 
 ::: moniker-end
 

aspnetcore/mvc/views/view-compilation/_static/razor-views-in-dll.png

@@ -53,4 +53,4 @@ public void Configure(IApplicationBuilder app)
         });
     }
 }
-#endregion
+#endregion