From b45a86aeea417ed70c6f11d608b0f5e558ffac82 Mon Sep 17 00:00:00 2001
From: lootle1 <175976130+lootle1@users.noreply.github.com>
Date: Thu, 30 Apr 2026 16:01:35 -0500
Subject: [PATCH] Light Freshness Edit: ASP.NET - mvc

---
 aspnetcore/mvc/overview.md       | 18 +++++++++---------
 aspnetcore/mvc/views/layout.md   | 30 +++++++++++++++---------------
 aspnetcore/mvc/views/overview.md | 20 ++++++++++----------
 aspnetcore/mvc/views/partial.md  |  4 ++--
 aspnetcore/mvc/views/razor.md    | 16 ++++++++--------
 5 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/aspnetcore/mvc/overview.md b/aspnetcore/mvc/overview.md
index 2abdbe4172f9..a097c08eb228 100644
--- a/aspnetcore/mvc/overview.md
+++ b/aspnetcore/mvc/overview.md
@@ -3,7 +3,7 @@ title: Overview of ASP.NET Core MVC
 author: ardalis
 description: Learn how ASP.NET Core MVC is a rich framework for building web apps and APIs using the Model-View-Controller design pattern.
 ms.author: tdykstra
-ms.date: 02/12/2020
+ms.date: 04/29/2026
 uid: mvc/overview
 ---
 # Overview of ASP.NET Core MVC
@@ -14,7 +14,7 @@ ASP.NET Core MVC is a rich framework for building web apps and APIs using the Mo
 
 ## MVC pattern
 
-The Model-View-Controller (MVC) architectural pattern separates an application into three main groups of components: Models, Views, and Controllers. This pattern helps to achieve [separation of concerns](/dotnet/standard/modern-web-apps-azure-architecture/architectural-principles#separation-of-concerns). Using this pattern, user requests are routed to a Controller which is responsible for working with the Model to perform user actions and/or retrieve results of queries. The Controller chooses the View to display to the user, and provides it with any Model data it requires.
+The Model-View-Controller (MVC) architectural pattern separates an application into three main groups of components: Models, Views, and Controllers. This pattern helps to achieve [separation of concerns](/dotnet/architecture/modern-web-apps-azure/architectural-principles#separation-of-concerns). Using this pattern, user requests are routed to a Controller, which is responsible for working with the Model to perform user actions and/or retrieve results of queries. The Controller chooses the View to display to the user, and provides it with any Model data it requires.
 
 The following diagram shows the three main components and which ones reference the others:
 
@@ -23,7 +23,7 @@ The following diagram shows the three main components and which ones reference t
 This delineation of responsibilities helps you scale the application in terms of complexity because it's easier to code, debug, and test something (model, view, or controller) that has a single job. It's more difficult to update, test, and debug code that has dependencies spread across two or more of these three areas. For example, user interface logic tends to change more frequently than business logic. If presentation code and business logic are combined in a single object, an object containing business logic must be modified every time the user interface is changed. This often introduces errors and requires the retesting of business logic after every minimal user interface change.
 
 > [!NOTE]
-> Both the view and the controller depend on the model. However, the model depends on neither the view nor the controller. This is one of the key benefits of the separation. This separation allows the model to be built and tested independent of the visual presentation.
+> Both the view and the controller depend on the model. However, the model doesn't depend on the view or the controller. This is one of the key benefits of the separation. This separation allows the model to be built and tested independent of the visual presentation.
 
 ### Model Responsibilities
 
@@ -39,7 +39,7 @@ Controllers are the components that handle user interaction, work with the model
 
 > [!NOTE]
 > Controllers shouldn't be overly complicated by too many responsibilities. To keep controller logic from becoming overly complex, push business logic out of the controller and into the domain model.
-
+>
 >[!TIP]
 > If you find that your controller actions frequently perform the same kinds of actions, move these common actions into [filters](#filters).
 
@@ -116,11 +116,11 @@ public async Task<IActionResult> Login(LoginViewModel model, string returnUrl =
 }
 ```
 
-The framework handles validating request data both on the client and on the server. Validation logic specified on model types is added to the rendered views as unobtrusive annotations and is enforced in the browser with [jQuery Validation](https://jqueryvalidation.org/).
+The framework handles validating request data both on the client and on the server. Validation logic specified on model types is added to the rendered views as unobtrusive annotations and is enforced in the browser with [jQuery Validation](https://github.com/jquery-validation/jquery-validation).
 
 ## Dependency injection
 
-ASP.NET Core has built-in support for [dependency injection (DI)](../fundamentals/dependency-injection.md). In ASP.NET Core MVC, [controllers](controllers/dependency-injection.md) can request needed services through their constructors, allowing them to follow the [Explicit Dependencies Principle](/dotnet/standard/modern-web-apps-azure-architecture/architectural-principles#explicit-dependencies).
+ASP.NET Core has built-in support for [dependency injection (DI)](../fundamentals/dependency-injection.md). In ASP.NET Core MVC, [controllers](controllers/dependency-injection.md) can request needed services through their constructors, allowing them to follow the [Explicit Dependencies Principle](/dotnet/architecture/modern-web-apps-azure/architectural-principles#explicit-dependencies).
 
 Your app can also use [dependency injection in view files](views/dependency-injection.md), using the `@inject` directive:
 
@@ -149,7 +149,7 @@ public class AccountController : Controller
 
 ## Areas
 
-[Areas](controllers/areas.md) provide a way to partition a large ASP.NET Core MVC Web app into smaller functional groupings. An area is an MVC structure inside an application. In an MVC project, logical components like Model, Controller, and View are kept in different folders, and MVC uses naming conventions to create the relationship between these components. For a large app, it may be advantageous to partition the app into separate high level areas of functionality. For instance, an e-commerce app with multiple business units, such as checkout, billing, and search etc. Each of these units have their own logical component views, controllers, and models.
+[Areas](controllers/areas.md) provide a way to partition a large ASP.NET Core MVC Web app into smaller functional groupings. An area is an MVC structure inside an application. In an MVC project, logical components like Model, Controller, and View are kept in different folders, and MVC uses naming conventions to create the relationship between these components. For a large app, it might be advantageous to partition the app into separate high level areas of functionality. For instance, an e-commerce app with multiple business units, such as checkout, billing, and search etc. Each of these units have their own logical component views, controllers, and models.
 
 ## Web APIs
 
@@ -157,7 +157,7 @@ In addition to being a great platform for building web sites, ASP.NET Core MVC h
 
 The framework includes support for HTTP content-negotiation with built-in support to [format data](xref:web-api/advanced/formatting) as JSON or XML. Write [custom formatters](xref:web-api/advanced/custom-formatters) to add support for your own formats.
 
-Use link generation to enable support for hypermedia. Easily enable support for [Cross-Origin Resource Sharing (CORS)](https://www.w3.org/TR/cors/) so that your Web APIs can be shared across multiple Web applications.
+Use link generation to enable support for hypermedia. Easily enable support for [Cross-Origin Resource Sharing (CORS)](https://fetch.spec.whatwg.org/#http-cors-protocol) so that your Web APIs can be shared across multiple Web applications.
 
 ## Testability
 
@@ -165,7 +165,7 @@ The framework's use of interfaces and dependency injection make it well-suited t
 
 ## Razor view engine
 
-[ASP.NET Core MVC views](views/overview.md) use the [Razor view engine](views/razor.md) to render views. Razor is a compact, expressive and fluid template markup language for defining views using embedded C# code. Razor is used to dynamically generate web content on the server. You can cleanly mix server code with client side content and code.
+[ASP.NET Core MVC views](views/overview.md) use the [Razor view engine](views/razor.md) to render views. Razor is a compact, expressive, and fluid template markup language for defining views using embedded C# code. Razor is used to dynamically generate web content on the server. You can cleanly mix server code with client side content and code.
 
 ```cshtml
 <ul>
diff --git a/aspnetcore/mvc/views/layout.md b/aspnetcore/mvc/views/layout.md
index 134a106277f5..511f219ae8de 100644
--- a/aspnetcore/mvc/views/layout.md
+++ b/aspnetcore/mvc/views/layout.md
@@ -3,7 +3,7 @@ title: Layout in ASP.NET Core
 author: tdykstra
 description: Learn how to use common layouts, share directives, and run common code before rendering views in an ASP.NET Core app.
 ms.author: tdykstra
-ms.date: 07/30/2019
+ms.date: 04/29/2026
 uid: mvc/views/layout
 ---
 # Layout in ASP.NET Core
@@ -16,7 +16,7 @@ Pages and views frequently share visual and programmatic elements. This article
 * Share directives.
 * Run common code before rendering pages or views.
 
-This document discusses layouts for the two different approaches to ASP.NET Core MVC: Razor Pages and controllers with views. For this topic, the differences are minimal:
+This document discusses layouts for the two different approaches to ASP.NET Core MVC: Razor Pages and controllers with views. For this article, the differences are minimal:
 
 * Razor Pages are in the *Pages* folder.
 * Controllers with views uses a *Views* folder for views.
@@ -27,7 +27,7 @@ Most web apps have a common layout that provides the user with a consistent expe
 
 ![Page Layout example](layout/_static/page-layout.png)
 
-Common HTML structures such as scripts and stylesheets are also frequently used by many pages within an app. All of these shared elements may be defined in a *layout* file, which can then be referenced by any view used within the app. Layouts reduce duplicate code in views.
+Common HTML structures such as scripts and stylesheets are also frequently used by many pages within an app. All of these shared elements might be defined in a *layout* file, which any view used within the app can then reference. Layouts reduce duplicate code in views.
 
 By convention, the default layout for an ASP.NET Core app is named `_Layout.cshtml`. The layout files for new ASP.NET Core projects created with the templates are:
 
@@ -87,13 +87,13 @@ The following markup uses the [Partial Tag Helper](xref:mvc/views/tag-helpers/bu
 }
 ```
 
-The preceding markup was generated by [scaffolding Identity](xref:security/authentication/scaffold-identity).
+[Scaffolding Identity](xref:security/authentication/scaffold-identity) generated the preceding markup.
 
-Sections defined in a page or view are available only in its immediate layout page. They cannot be referenced from partials, view components, or other parts of the view system.
+Sections defined in a page or view are available only in its immediate layout page. They can't be referenced from partials, view components, or other parts of the view system.
 
 ### Ignoring sections
 
-By default, the body and all sections in a content page must all be rendered by the layout page. The Razor view engine enforces this by tracking whether the body and each section have been rendered.
+By default, the layout page must render the body and all sections in a content page. The Razor view engine enforces this by tracking whether the body and each section have been rendered.
 
 To instruct the view engine to ignore the body or sections, call the `IgnoreBody` and `IgnoreSection` methods.
 
@@ -103,7 +103,7 @@ The body and every section in a Razor page must be either rendered or ignored.
 
 ## Importing Shared Directives
 
-Views and pages can use Razor directives to import namespaces and use [dependency injection](dependency-injection.md). Directives shared by many views may be specified in a common `_ViewImports.cshtml` file. The `_ViewImports` file supports the following directives:
+Views and pages can use Razor directives to import namespaces and use [dependency injection](dependency-injection.md). Directives shared by many views might be specified in a common `_ViewImports.cshtml` file. The `_ViewImports` file supports the following directives:
 
 * `@addTagHelper`
 * `@removeTagHelper`
@@ -120,7 +120,7 @@ A sample `_ViewImports.cshtml` file:
 
 [!code-cshtml[](../../common/samples/WebApplication1/Views/_ViewImports.cshtml)]
 
-The `_ViewImports.cshtml` file for an ASP.NET Core MVC app is typically placed in the *Pages* (or *Views*) folder. A `_ViewImports.cshtml` file can be placed within any folder, in which case it will only be applied to pages or views within that folder and its subfolders. `_ViewImports` files are processed starting at the root level and then for each folder leading up to the location of the page or view itself. `_ViewImports` settings specified at the root level may be overridden at the folder level.
+The `_ViewImports.cshtml` file for an ASP.NET Core MVC app is typically placed in the *Pages* (or *Views*) folder. A `_ViewImports.cshtml` file can be placed within any folder, in which case it will only be applied to pages or views within that folder and its subfolders. `_ViewImports` files are processed starting at the root level and then for each folder leading up to the location of the page or view itself. `_ViewImports` settings specified at the root level might be overridden at the folder level.
 
 For example, suppose:
 
@@ -131,12 +131,12 @@ Pages and views in the subfolder will have access to both Tag Helpers and the `M
 
 If multiple `_ViewImports.cshtml` files are found in the file hierarchy, the combined behavior of the directives are:
 
-* `@addTagHelper`, `@removeTagHelper`: all run, in order
-* `@tagHelperPrefix`: the closest one to the view overrides any others
-* `@model`: the closest one to the view overrides any others
-* `@inherits`: the closest one to the view overrides any others
-* `@using`: all are included; duplicates are ignored
-* `@inject`: for each property, the closest one to the view overrides any others with the same property name
+* `@addTagHelper`, `@removeTagHelper`: All run, in order.
+* `@tagHelperPrefix`: The closest one to the view overrides any others.
+* `@model`: The closest one to the view overrides any others.
+* `@inherits`: The closest one to the view overrides any others.
+* `@using`: All are included; duplicates are ignored.
+* `@inject`: For each property, the closest one to the view overrides any others with the same property name.
 
 <a name="viewstart"></a>
 
@@ -148,6 +148,6 @@ A sample `_ViewStart.cshtml` file:
 
 [!code-cshtml[](../../common/samples/WebApplication1/Views/_ViewStart.cshtml)]
 
-The file above specifies that all views will use the `_Layout.cshtml` layout.
+The preceding file specifies that all views will use the `_Layout.cshtml` layout.
 
 `_ViewStart.cshtml` and `_ViewImports.cshtml` are **not** typically placed in the */Pages/Shared* (or */Views/Shared*) folder. The app-level versions of these files should be placed directly in the */Pages* (or */Views*) folder.
diff --git a/aspnetcore/mvc/views/overview.md b/aspnetcore/mvc/views/overview.md
index 0d9841a94ec8..0ba9d8bcfa54 100644
--- a/aspnetcore/mvc/views/overview.md
+++ b/aspnetcore/mvc/views/overview.md
@@ -4,7 +4,7 @@ author: tdykstra
 description: Learn how views handle the app's data presentation and user interaction in ASP.NET Core MVC.
 monikerRange: '>= aspnetcore-3.1'
 ms.author: tdykstra
-ms.date: 12/05/2019
+ms.date: 04/29/2026
 uid: mvc/views/overview
 ---
 # Views in ASP.NET Core MVC
@@ -19,7 +19,7 @@ In ASP.NET Core MVC, views are `.cshtml` files that use the [C# programming lang
 
 ![Views folder in Solution Explorer of Visual Studio is open with the Home folder open to show About.cshtml, Contact.cshtml, and Index.cshtml files](overview/_static/views_solution_explorer.png)
 
-The `Home` controller is represented by a `Home` folder inside the `Views` folder. The `Home` folder contains the views for the `About`, `Contact`, and `Index` (homepage) webpages. When a user requests one of these three webpages, controller actions in the `Home` controller determine which of the three views is used to build and return a webpage to the user.
+A `Home` folder inside the `Views` folder represents the `Home` controller. The `Home` folder contains the views for the `About`, `Contact`, and `Index` (homepage) webpages. When a user requests one of these three webpages, controller actions in the `Home` controller determine which of the three views is used to build and return a webpage to the user.
 
 Use [layouts](xref:mvc/views/layout) to provide consistent webpage sections and reduce code repetition. Layouts often contain the header, navigation and menu elements, and the footer. The header and footer usually contain boilerplate markup for many metadata elements and links to script and style assets. Layouts help you avoid this boilerplate markup in your views.
 
@@ -29,7 +29,7 @@ Use [layouts](xref:mvc/views/layout) to provide consistent webpage sections and
 
 ## Benefits of using views
 
-Views help to establish [separation of concerns](/dotnet/standard/modern-web-apps-azure-architecture/architectural-principles#separation-of-concerns) within an MVC app by separating the user interface markup from other parts of the app. Following SoC design makes your app modular, which provides several benefits:
+Views help to establish [separation of concerns](/dotnet/architecture/modern-web-apps-azure/architectural-principles#separation-of-concerns) within an MVC app by separating the user interface markup from other parts of the app. Following SoC design makes your app modular, which provides several benefits:
 
 * The app is easier to maintain because it's better organized. Views are generally grouped by app feature. This makes it easier to find related views when working on a feature.
 * The parts of the app are loosely coupled. You can build and update the app's views separately from the business logic and data access components. You can modify the views of the app without necessarily having to update other parts of the app.
@@ -42,9 +42,9 @@ Views that are specific to a controller are created in the `Views/[ControllerNam
 
 [!code-cshtml[](../../common/samples/WebApplication1/Views/Home/About.cshtml)]
 
-[Razor markup](xref:mvc/views/razor) starts with the `@` symbol. Run C# statements by placing C# code within [Razor code blocks](xref:mvc/views/razor#razor-code-blocks) set off by curly braces (`{ ... }`). For example, see the assignment of "About" to `ViewData["Title"]` shown above. You can display values within HTML by simply referencing the value with the `@` symbol. See the contents of the `<h2>` and `<h3>` elements above.
+[Razor markup](xref:mvc/views/razor) starts with the `@` symbol. Run C# statements by placing C# code within [Razor code blocks](xref:mvc/views/razor#razor-code-blocks) set off by curly braces (`{ ... }`). For example, see the assignment of "About" to `ViewData["Title"]` shown previously. You can display values within HTML by simply referencing the value with the `@` symbol. See the contents of the `<h2>` and `<h3>` elements previous.
 
-The view content shown above is only part of the entire webpage that's rendered to the user. The rest of the page's layout and other common aspects of the view are specified in other view files. To learn more, see the [Layout topic](xref:mvc/views/layout).
+The view content shown previously is only part of the entire webpage that's rendered to the user. The rest of the page's layout and other common aspects of the view are specified in other view files. To learn more, see the [Layout topic](xref:mvc/views/layout).
 
 ## How controllers specify views
 
@@ -80,7 +80,7 @@ The `View` helper method has several overloads. You can optionally specify:
 
 ### View discovery
 
-When an action returns a view, a process called *view discovery* takes place. This process determines which view file is used based on the view name. 
+When an action returns a view, a process called *view discovery* takes place. This process determines which view file is used based on the view name.
 
 The default behavior of the `View` method (`return View();`) is to return a view with the same name as the action method from which it's called. For example, the `About` `ActionResult` method name of the controller is used to search for a view file named `About.cshtml`. First, the runtime looks in the `Views/[ControllerName]` folder for the view. If it doesn't find a matching view there, it searches the `Shared` folder for the view.
 
@@ -165,7 +165,7 @@ public IActionResult Contact()
 }
 ```
 
-There are no restrictions on the model types that you can provide to a view. We recommend using Plain Old CLR Object (POCO) viewmodels with little or no behavior (methods) defined. Usually, viewmodel classes are either stored in the `Models` folder or a separate `ViewModels` folder at the root of the app. The `Address` viewmodel used in the example above is a POCO viewmodel stored in a file named `Address.cs`:
+There are no restrictions on the model types that you can provide to a view. We recommend using Plain Old CLR Object (POCO) viewmodels with little or no behavior (methods) defined. Usually, viewmodel classes are either stored in the `Models` folder or a separate `ViewModels` folder at the root of the app. The `Address` viewmodel used in the previous example is a POCO viewmodel stored in a file named `Address.cs`:
 
 ```csharp
 namespace WebApplication1.ViewModels
@@ -279,7 +279,7 @@ In the layout, the title is read from the ViewData dictionary:
 
 `ViewBag` *isn't available by default for use in Razor Pages* `PageModel` *classes.*
 
-`ViewBag` is a `Microsoft.AspNetCore.Mvc.ViewFeatures.Internal.DynamicViewData` object that provides dynamic access to the objects stored in `ViewData`. `ViewBag` can be more convenient to work with, since it doesn't require casting. The following example shows how to use `ViewBag` with the same result as using `ViewData` above:
+`ViewBag` is a `Microsoft.AspNetCore.Mvc.ViewFeatures.Internal.DynamicViewData` object that provides dynamic access to the objects stored in `ViewData`. `ViewBag` can be more convenient to work with, since it doesn't require casting. The following example shows how to use `ViewBag` with the same result as using `ViewData` previously:
 
 ```csharp
 public IActionResult SomeAction()
@@ -380,9 +380,9 @@ This feature offers flexibility but doesn't offer compilation protection or Inte
 
 ## More view features
 
-[Tag Helpers](xref:mvc/views/tag-helpers/intro) make it easy to add server-side behavior to existing HTML tags. Using Tag Helpers avoids the need to write custom code or helpers within your views. Tag helpers are applied as attributes to HTML elements and are ignored by editors that can't process them. This allows you to edit and render view markup in a variety of tools.
+[Tag Helpers](xref:mvc/views/tag-helpers/intro) make it easy to add server-side behavior to existing HTML tags. Using Tag Helpers avoids the need to write custom code or helpers within your views. Tag helpers are applied as attributes to HTML elements and editors that can't process them ignore them. This allows you to edit and render view markup in a variety of tools.
 
-Generating custom HTML markup can be achieved with many built-in HTML Helpers. More complex user interface logic can be handled by [View Components](xref:mvc/views/view-components). View components provide the same SoC that controllers and views offer. They can eliminate the need for actions and views that deal with data used by common user interface elements.
+Generating custom HTML markup can be achieved with many built-in HTML Helpers. [View Components](xref:mvc/views/view-components) can handle more complex user interface logic. View components provide the same SoC that controllers and views offer. They can eliminate the need for actions and views that deal with data used by common user interface elements.
 
 Like many other aspects of ASP.NET Core, views support [dependency injection](xref:fundamentals/dependency-injection), allowing services to be [injected into views](xref:mvc/views/dependency-injection).
 
diff --git a/aspnetcore/mvc/views/partial.md b/aspnetcore/mvc/views/partial.md
index 396c2c3d39a0..e3864c52aee3 100644
--- a/aspnetcore/mvc/views/partial.md
+++ b/aspnetcore/mvc/views/partial.md
@@ -4,7 +4,7 @@ author: tdykstra
 description: Discover how to use partial views to break up large markup files and reduce the duplication of common markup across web pages in ASP.NET Core apps.
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 06/12/2019
+ms.date: 04/30/2026
 uid: mvc/views/partial
 ---
 # Partial views in ASP.NET Core
@@ -15,7 +15,7 @@ A partial view is a [Razor](xref:mvc/views/razor) markup file (`.cshtml`) withou
 
 :::moniker range=">= aspnetcore-2.1"
 
-The term *partial view* is used when developing either an MVC app, where markup files are called *views*, or a Razor Pages app, where markup files are called *pages*. This topic generically refers to MVC views and Razor Pages pages as *markup files*.
+The term *partial view* is used when developing either an MVC app, where markup files are called *views*, or a Razor Pages app, where markup files are called *pages*. This article generically refers to MVC views and Razor Pages pages as *markup files*.
 
 :::moniker-end
 
diff --git a/aspnetcore/mvc/views/razor.md b/aspnetcore/mvc/views/razor.md
index 957a60196bcb..2b43c6c91ec2 100644
--- a/aspnetcore/mvc/views/razor.md
+++ b/aspnetcore/mvc/views/razor.md
@@ -3,16 +3,16 @@ title: Razor syntax reference for ASP.NET Core
 author: tdykstra
 description: Learn about Razor markup syntax for embedding server-based code into webpages.
 ms.author: tdykstra
-ms.date: 02/12/2020
+ms.date: 04/30/2026
 uid: mvc/views/razor
 ---
 # Razor syntax reference for ASP.NET Core
 
 By [Rick Anderson](https://twitter.com/RickAndMSFT), [Taylor Mullen](https://twitter.com/ntaylormullen), and [Dan Vicarel](https://github.com/Rabadash8820)
 
-Razor is a markup syntax for embedding .NET based code into webpages. The Razor syntax consists of Razor markup, C#, and HTML. Files containing Razor generally have a `.cshtml` file extension. Razor is also found in [Razor component](xref:blazor/components/index) files (`.razor`). Razor syntax is similar to the templating engines of various JavaScript single-page application (SPA) frameworks, such as Angular, React, VueJs, and Svelte. For more information see, <xref:client-side/spa-services>.
+Razor is a markup syntax for embedding .NET based code into webpages. The Razor syntax consists of Razor markup, C#, and HTML. Files containing Razor generally have a `.cshtml` file extension. Razor is also found in [Razor component](xref:blazor/components/index) files (`.razor`). Razor syntax is similar to the templating engines of various JavaScript single-page application (SPA) frameworks, such as Angular, React, VueJs, and Svelte. For more information, see <xref:client-side/spa-services>.
 
-[Introduction to ASP.NET Web Programming Using the Razor Syntax](/aspnet/web-pages/overview/getting-started/introducing-razor-syntax-c) provides many samples of programming with Razor syntax. Although the topic was written for ASP.NET rather than ASP.NET Core, most of the samples apply to ASP.NET Core.
+[Introduction to ASP.NET Web Programming Using the Razor Syntax](/aspnet/web-pages/overview/getting-started/introducing-razor-syntax-c) provides many samples of programming with Razor syntax. Although the article was written for ASP.NET rather than ASP.NET Core, most of the samples apply to ASP.NET Core.
 
 ## Rendering HTML
 
@@ -46,7 +46,7 @@ HTML attributes and content containing email addresses don't treat the `@` symbo
 
 ### Scalable Vector Graphics (SVG)
 
-[SVG](https://developer.mozilla.org/docs/Web/SVG) [foreignObject](https://developer.mozilla.org/docs/Web/SVG/Element/foreignObject) elements are supported:
+[SVG](https://developer.mozilla.org/docs/Web/SVG) [foreignObject](https://developer.mozilla.org/docs/Web/SVG/Reference/Element/foreignObject) elements are supported:
 
 ```html
 @{
@@ -73,7 +73,7 @@ Implicit Razor expressions start with `@` followed by C# code:
 <p>@DateTime.IsLeapYear(2016)</p>
 ```
 
-With the exception of the C# `await` keyword, implicit expressions must not contain spaces. If the C# statement has a clear ending, spaces can be intermingled:
+Except for the C# `await` keyword, implicit expressions must not contain spaces. If the C# statement has a clear ending, spaces can be intermingled:
 
 ```razor
 <p>@await DoSomething("hello", "world")</p>
@@ -88,7 +88,7 @@ Implicit expressions **cannot** contain C# generics, as the characters inside th
 The preceding code generates a compiler error similar to one of the following:
 
 * The "int" element wasn't closed. All elements must be either self-closing or have a matching end tag.
-* Cannot convert method group 'GenericMethod' to non-delegate type 'object'. Did you intend to invoke the method?`
+* Can't convert method group 'GenericMethod' to non-delegate type 'object'. Did you intend to invoke the method?`
 
 Generic method calls must be wrapped in an [explicit Razor expression](#explicit-razor-expressions) or a [Razor code block](#razor-code-blocks).
 
@@ -898,7 +898,7 @@ Razor templates allow you to define a UI snippet with the following format:
 @<tag>...</tag>
 ```
 
-The following example illustrates how to specify a templated Razor delegate as a <xref:System.Func%602>. The [dynamic type](/dotnet/csharp/programming-guide/types/using-type-dynamic) is specified for the parameter of the method that the delegate encapsulates. An [object type](/dotnet/csharp/language-reference/keywords/object) is specified as the return value of the delegate. The template is used with a <xref:System.Collections.Generic.List%601> of `Pet` that has a `Name` property.
+The following example illustrates how to specify a templated Razor delegate as a <xref:System.Func%602>. The [dynamic type](/dotnet/csharp/programming-guide/types/using-type-dynamic) is specified for the parameter of the method that the delegate encapsulates. An [object type](/dotnet/csharp/language-reference/builtin-types/reference-types) is specified as the return value of the delegate. The template is used with a <xref:System.Collections.Generic.List%601> of `Pet` that has a `Name` property.
 
 ```csharp
 public class Pet
@@ -1100,7 +1100,7 @@ To view the generated class for `Pages/Index.cshtml`, open `obj/Debug/netcoreapp
 
 ## View lookups and case sensitivity
 
-The Razor view engine performs case-sensitive lookups for views. However, the actual lookup is determined by the underlying file system:
+The Razor view engine performs case-sensitive lookups for views. However, the underlying file system determines the actual lookup:
 
 * File based source:
   * On operating systems with case insensitive file systems (for example, Windows), physical file provider lookups are case insensitive. For example, `return View("Test")` results in matches for `/Views/Home/Test.cshtml`, `/Views/home/test.cshtml`, and any other casing variant.