From cace8a2c4ce3719f14a2a16181bd8b647d4007f1 Mon Sep 17 00:00:00 2001
From: lootle1 <175976130+lootle1@users.noreply.github.com>
Date: Mon, 4 May 2026 11:23:29 -0500
Subject: [PATCH 1/3] Light Freshness Edit: ASP.NET - mvc, test, and web-api

---
 aspnetcore/mvc/views/tag-helpers/intro.md | 28 +++++++++++------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/aspnetcore/mvc/views/tag-helpers/intro.md b/aspnetcore/mvc/views/tag-helpers/intro.md
index d722b9d14c06..9dd21ec2f036 100644
--- a/aspnetcore/mvc/views/tag-helpers/intro.md
+++ b/aspnetcore/mvc/views/tag-helpers/intro.md
@@ -4,7 +4,7 @@ author: tdykstra
 description: Learn what Tag Helpers are and how to use them in ASP.NET Core.
 ms.author: tdykstra
 ms.custom: H1Hack27Feb2017, sfi-image-nochange
-ms.date: 03/18/2019
+ms.date: 05/04/2026
 uid: mvc/views/tag-helpers/intro
 ---
 # Tag Helpers in ASP.NET Core
@@ -14,21 +14,21 @@ By [Rick Anderson](https://twitter.com/RickAndMSFT)
 ## What are Tag Helpers
 
 Tag Helpers enable server-side code to participate in creating and rendering HTML elements in Razor files. For example, the built-in `ImageTagHelper` can append a version number to the image name. Whenever the image changes, the server generates a new unique version for the image, so clients are guaranteed to get the current image (instead of a stale cached image). There are many built-in Tag Helpers for common tasks - such as creating forms, links, loading assets and more - and even more available in public GitHub repositories and as NuGet packages. Tag Helpers are authored in C#, and they target HTML elements based on element name, attribute name, or parent tag. For example, the built-in `LabelTagHelper` can target the HTML `<label>` element when the
-`LabelTagHelper` attributes are applied. If you're familiar with HTML Helpers, Tag Helpers reduce the explicit transitions between HTML and C# in Razor views. In many cases, HTML Helpers provide an alternative approach to a specific Tag Helper, but it's important to recognize that Tag Helpers don't replace HTML Helpers and there's not a Tag Helper for each HTML Helper. [Tag Helpers compared to HTML Helpers](#tag-helpers-compared-to-html-helpers) explains the differences in more detail.
+`LabelTagHelper` attributes are applied. If you're familiar with HTML Helpers, Tag Helpers reduce the explicit transitions between HTML and C# in Razor views. In many cases, HTML Helpers provide an alternative approach to a specific Tag Helper, but it's important to recognize that Tag Helpers don't replace HTML Helpers. There's not a Tag Helper for each HTML Helper. [Tag Helpers compared to HTML Helpers](#tag-helpers-compared-to-html-helpers) explains the differences in more detail.
 
 Tag Helpers aren't supported in Razor components. For more information, see <xref:blazor/components/index#tag-helpers-arent-supported-in-components>.
 
 ## What Tag Helpers provide
 
-**An HTML-friendly development experience**
+### An HTML-friendly development experience
 
-   For the most part, Razor markup using Tag Helpers looks like standard HTML. Front-end designers conversant with HTML/CSS/JavaScript can edit Razor without learning C# Razor syntax.
+   Usually, Razor markup using Tag Helpers looks like standard HTML. Front-end designers conversant with HTML/CSS/JavaScript can edit Razor without learning C# Razor syntax.
 
-**A rich IntelliSense environment for creating HTML and Razor markup**
+### A rich IntelliSense environment for creating HTML and Razor markup
 
    This is in sharp contrast to HTML Helpers, the previous approach to server-side creation of markup in Razor views. [Tag Helpers compared to HTML Helpers](#tag-helpers-compared-to-html-helpers) explains the differences in more detail. [IntelliSense support for Tag Helpers](#intellisense-support-for-tag-helpers) explains the IntelliSense environment. Even developers experienced with Razor C# syntax are more productive using Tag Helpers than writing C# Razor markup.
 
-**A way to make you more productive and able to produce more robust, reliable, and maintainable code using information only available on the server**
+### A way to make you more productive and able to produce more robust, reliable, and maintainable code using information only available on the server
 
    For example, historically the mantra on updating images was to change the name of the image when you change the image. Images should be aggressively cached for performance reasons, and unless you change the name of an image, you risk clients getting a stale copy. Historically, after an image was edited, the name had to be changed and each reference to the image in the web app needed to be updated. Not only is this very labor intensive, it's also error prone (you could miss a reference, accidentally enter the wrong string, etc.) The built-in `ImageTagHelper` can do this for you automatically. The `ImageTagHelper` can append a version number to the image name, so whenever the image changes, the server automatically generates a new unique version for the image. Clients are guaranteed to get the current image. This robustness and labor savings comes essentially free by using the `ImageTagHelper`.
 
@@ -71,7 +71,7 @@ If you create a new ASP.NET Core web app named *AuthoringTagHelpers*, the follow
 
 [!code-cshtml[](../../../mvc/views/tag-helpers/authoring/sample/AuthoringTagHelpers/src/AuthoringTagHelpers/Views/_ViewImportsCopy.cshtml?highlight=2&range=2-3)]
 
-The `@addTagHelper` directive makes Tag Helpers available to the view. In this case, the view file is `Pages/_ViewImports.cshtml`, which by default is inherited by all files in the *Pages* folder and subfolders; making Tag Helpers available. The code above uses the wildcard syntax ("\*") to specify that all Tag Helpers in the specified assembly (*Microsoft.AspNetCore.Mvc.TagHelpers*) will be available to every view file in the *Views* directory or subdirectory. The first parameter after `@addTagHelper` specifies the Tag Helpers to load (we are using "\*" for all Tag Helpers), and the second parameter "Microsoft.AspNetCore.Mvc.TagHelpers" specifies the assembly containing the Tag Helpers. *Microsoft.AspNetCore.Mvc.TagHelpers* is the assembly for the built-in ASP.NET Core Tag Helpers.
+The `@addTagHelper` directive makes Tag Helpers available to the view. In this case, the view file is `Pages/_ViewImports.cshtml`, which by default is inherited by all files in the *Pages* folder and subfolders; making Tag Helpers available. The preceding code uses the wildcard syntax ("\*") to specify that all Tag Helpers in the specified assembly (*Microsoft.AspNetCore.Mvc.TagHelpers*) will be available to every view file in the *Views* directory or subdirectory. The first parameter after `@addTagHelper` specifies the Tag Helpers to load (we're using "\*" for all Tag Helpers), and the second parameter "Microsoft.AspNetCore.Mvc.TagHelpers" specifies the assembly containing the Tag Helpers. *Microsoft.AspNetCore.Mvc.TagHelpers* is the assembly for the built-in ASP.NET Core Tag Helpers.
 
 To expose all of the Tag Helpers in this project (which creates an assembly named *AuthoringTagHelpers*), you would use the following:
 
@@ -102,7 +102,7 @@ The `@removeTagHelper` has the same two parameters as `@addTagHelper`, and it re
 
 ### Controlling Tag Helper scope with the `_ViewImports.cshtml` file
 
-You can add a `_ViewImports.cshtml` to any view folder, and the view engine applies the directives from both that file and the `Views/_ViewImports.cshtml` file. If you added an empty `Views/Home/_ViewImports.cshtml` file for the *Home* views, there would be no change because the `_ViewImports.cshtml` file is additive. Any `@addTagHelper` directives you add to the `Views/Home/_ViewImports.cshtml` file (that are not in the default `Views/_ViewImports.cshtml` file) would expose those Tag Helpers to views only in the *Home* folder.
+You can add a `_ViewImports.cshtml` to any view folder, and the view engine applies the directives from both that file and the `Views/_ViewImports.cshtml` file. If you added an empty `Views/Home/_ViewImports.cshtml` file for the *Home* views, there would be no change because the `_ViewImports.cshtml` file is additive. Any `@addTagHelper` directives you add to the `Views/Home/_ViewImports.cshtml` file (that aren't in the default `Views/_ViewImports.cshtml` file) would expose those Tag Helpers to views only in the *Home* folder.
 
 <a name="opt-out"></a>
 
@@ -126,7 +126,7 @@ The `@tagHelperPrefix` directive allows you to specify a tag prefix string to en
 @tagHelperPrefix th:
 ```
 
-In the code image below, the Tag Helper prefix is set to `th:`, so only those elements using the prefix `th:` support Tag Helpers (Tag Helper-enabled elements have a distinctive font). The `<label>` and `<input>` elements have the Tag Helper prefix and are Tag Helper-enabled, while the `<span>` element doesn't.
+In the code image that follows, the Tag Helper prefix is set to `th:`, so only those elements using the prefix `th:` support Tag Helpers (Tag Helper-enabled elements have a distinctive font). The `<label>` and `<input>` elements have the Tag Helper prefix and are Tag Helper-enabled, while the `<span>` element doesn't.
 
 ![Razor markup with Tag Helper prefix set to "th:" for a label and an input element name](intro/_static/thp.png)
 
@@ -134,11 +134,11 @@ The same hierarchy rules that apply to `@addTagHelper` also apply to `@tagHelper
 
 ## Self-closing Tag Helpers
 
-Many Tag Helpers can't be used as self-closing tags. Some Tag Helpers are designed to be self-closing tags. Using a Tag Helper that was not designed to be self-closing suppresses the rendered output. Self-closing a Tag Helper results in a self-closing tag in the rendered output. For more information, see [this note](xref:mvc/views/tag-helpers/authoring#self-closing) in [Authoring Tag Helpers](xref:mvc/views/tag-helpers/authoring).
+Many Tag Helpers can't be used as self-closing tags. Some Tag Helpers are designed to be self-closing tags. Using a Tag Helper that wasn't designed to be self-closing suppresses the rendered output. Self-closing a Tag Helper results in a self-closing tag in the rendered output. For more information, see [this note](xref:mvc/views/tag-helpers/authoring#self-closing) in [Authoring Tag Helpers](xref:mvc/views/tag-helpers/authoring).
 
 ## C# in Tag Helpers attribute/declaration
 
-Tag Helpers do not allow C# in the element's attribute or tag declaration area. For example, the following code is not valid:
+Tag Helpers don't allow C# in the element's attribute or tag declaration area. For example, the following code isn't valid:
 
 ```cshtml
 <input asp-for="LastName"  
@@ -203,11 +203,11 @@ IntelliSense statement completion allows you to enter the tab key to complete th
 
 ![The user has typed an opening bracket, the HTML element name "label", and begins to type an attribute name ("as"). IntelliSense presents a dialog of suggestions with "asp-for" selected.](intro/_static/stmtcomplete.png)
 
-As soon as a Tag Helper attribute is entered, the tag and attribute fonts change. Using the default Visual Studio "Blue" or "Light" color theme, the font is bold purple. If you're using the "Dark" theme the font is bold teal. The images in this document were taken using the default theme.
+As soon as a Tag Helper attribute is entered, the tag and attribute fonts change. Using the default Visual Studio "Blue" or "Light" color theme, the font is bold purple. If you're using the "Dark" theme, the font is bold teal. The images in this document were taken using the default theme.
 
 ![The user selected "asp-for", which is now in bold purple because the user isn't using the Dark theme.](intro/_static/labelaspfor2.png)
 
-You can enter the Visual Studio *CompleteWord* shortcut (Ctrl +spacebar is the [default](/visualstudio/ide/default-keyboard-shortcuts-in-visual-studio)) inside the double quotes (""), and you are now in C#, just like you would be in a C# class. IntelliSense displays all the methods and properties on the page model. The methods and properties are available because the property type is `ModelExpression`. In the image below, I'm editing the `Register` view, so the `RegisterViewModel` is available.
+You can enter the Visual Studio *CompleteWord* shortcut (Ctrl +spacebar is the [default](/visualstudio/ide/default-keyboard-shortcuts-in-visual-studio)) inside the double quotes (""), and you're now in C#, just like you would be in a C# class. IntelliSense displays all the methods and properties on the page model. The methods and properties are available because the property type is `ModelExpression`. In the following image, I'm editing the `Register` view, so the `RegisterViewModel` is available.
 
 ![The user types "e" in the value for the "asp-for" attribute. IntelliSense suggests possible completion with "Email" selected.](intro/_static/intellemail.png)
 
@@ -271,7 +271,7 @@ The Visual Studio editor helps you write **all** of the markup in the Tag Helper
 
 ## Tag Helpers compared to Web Server Controls
 
-* Tag Helpers don't own the element they're associated with; they simply participate in the rendering of the element and content. ASP.NET Web Server Controls are declared and invoked on a page.
+* Tag Helpers don't own the element they're associated with; they participate in the rendering of the element and content. ASP.NET Web Server Controls are declared and invoked on a page.
 
 * ASP.NET Web Server Controls have a non-trivial lifecycle that can make developing and debugging difficult.
 

From ecc2cbb836fcb6c6d1e7b5bf76a8923a6adcef99 Mon Sep 17 00:00:00 2001
From: lootle1 <175976130+lootle1@users.noreply.github.com>
Date: Tue, 5 May 2026 10:43:29 -0500
Subject: [PATCH 2/3] Edits

---
 aspnetcore/mvc/views/view-components.md    | 40 +++++++--------
 aspnetcore/mvc/views/working-with-forms.md | 60 +++++++++++-----------
 2 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/aspnetcore/mvc/views/view-components.md b/aspnetcore/mvc/views/view-components.md
index f6abdd7a959a..8fa21d838429 100644
--- a/aspnetcore/mvc/views/view-components.md
+++ b/aspnetcore/mvc/views/view-components.md
@@ -4,7 +4,7 @@ author: tdykstra
 description: Learn how view components are used in ASP.NET Core and how to add them to apps.
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 04/20/2022
+ms.date: 05/04/2026
 monikerRange: '>= aspnetcore-3.1'
 uid: mvc/views/view-components
 ---
@@ -16,7 +16,7 @@ By [Rick Anderson](https://twitter.com/RickAndMSFT)
 
 ## View components
 
-View components are similar to partial views, but they're much more powerful. View components don't use model binding, they depend on the data passed when calling the view component. This article was written using controllers and views, but view components work with [Razor Pages](https://www.learnrazorpages.com/razor-pages/view-components).
+View components are similar to partial views, but they're much more powerful. View components don't use model binding. They depend on the data passed when calling the view component. This article was written using controllers and views, but view components work with [Razor Pages](https://www.learnrazorpages.com/razor-pages/view-components).
 
 A view component:
 
@@ -27,17 +27,17 @@ A view component:
 
 View components are intended anywhere reusable rendering logic that's too complex for a partial view, such as:
 
-* Dynamic navigation menus
-* Tag cloud, where it queries the database
-* Sign in panel
-* Shopping cart
-* Recently published articles
-* Sidebar content on a blog
-* A sign in panel that would be rendered on every page and show either the links to sign out or sign in, depending on the sign in state of the user
+* Dynamic navigation menus.
+* Tag cloud, where it queries the database.
+* Sign in panel.
+* Shopping cart.
+* Recently published articles.
+* Sidebar content on a blog.
+* A sign in panel that would be rendered on every page and show either the links to sign out or sign in, depending on the sign in state of the user.
 
 A view component consists of two parts:
 
-* The class, typically derived from <xref:Microsoft.AspNetCore.Mvc.ViewComponent>
+* The class, typically derived from <xref:Microsoft.AspNetCore.Mvc.ViewComponent>.
 * The result it returns, typically a view.
 
 Like controllers, a view component can be a POCO, but most developers take advantage of the methods and properties available by deriving from <xref:Microsoft.AspNetCore.Mvc.ViewComponent>.
@@ -50,18 +50,18 @@ This section contains the high-level requirements to create a view component. La
 
 ### The view component class
 
-A view component class can be created by any of the following:
+Any of the following can create a view component class:
 
-* Deriving from <xref:Microsoft.AspNetCore.Mvc.ViewComponent>
-* Decorating a class with the [`[ViewComponent]`](xref:Microsoft.AspNetCore.Mvc.ViewComponentAttribute) attribute, or deriving from a class with the `[ViewComponent]` attribute
-* Creating a class where the name ends with the suffix [`ViewComponent`](xref:Microsoft.AspNetCore.Mvc.ViewComponents)
+* Deriving from <xref:Microsoft.AspNetCore.Mvc.ViewComponent>.
+* Decorating a class with the [`[ViewComponent]`](xref:Microsoft.AspNetCore.Mvc.ViewComponentAttribute) attribute, or deriving from a class with the `[ViewComponent]` attribute.
+* Creating a class where the name ends with the suffix [`ViewComponent`](xref:Microsoft.AspNetCore.Mvc.ViewComponents).
 
 Like controllers, view components must be public, non-nested, and non-abstract classes. The view component name is the class name with the `ViewComponent` suffix removed. It can also be explicitly specified using the <xref:Microsoft.AspNetCore.Mvc.ViewComponentAttribute.Name%2A> property.
 
 A view component class:
 
-* Supports constructor [dependency injection](../../fundamentals/dependency-injection.md)
-* Doesn't take part in the controller lifecycle, therefore [filters](../controllers/filters.md) can't be used in a view component
+* Supports constructor [dependency injection](../../fundamentals/dependency-injection.md).
+* Doesn't take part in the controller lifecycle, therefore [filters](../controllers/filters.md) can't be used in a view component.
 
 To prevent a class that has a case-insensitive `ViewComponent` suffix from being treated as a view component, decorate the class with the [`[NonViewComponent]`](xref:Microsoft.AspNetCore.Mvc.NonViewComponentAttribute) attribute:
 
@@ -124,7 +124,7 @@ A View Component can be invoked as a [Tag Helper](xref:mvc/views/tag-helpers/int
 
 [!code-cshtml[](view-components/sample6.x/ViewComponentSample/Views/ToDo/IndexTagHelper.cshtml?name=snippet&highlight=8-9)]
 
-Pascal-cased class and method parameters for Tag Helpers are translated into their [kebab case](https://stackoverflow.com/questions/11273282/whats-the-name-for-dash-separated-case/12273101). The Tag Helper to invoke a view component uses the `<vc></vc>` element. The view component is specified as follows:
+Pascal-cased class and method parameters for Tag Helpers are translated into their [kebab case](https://stackoverflow.com/questions/11273282/whats-the-name-for-hyphen-separated-case/12273101#12273101). The Tag Helper to invoke a view component uses the `<vc></vc>` element. The view component is specified as follows:
 
 ```cshtml
 <vc:[view-component-name]
@@ -157,7 +157,7 @@ In the following example, the view component is called directly from the control
 
 ## Create a basic view component
 
-[Download](https://github.com/dotnet/AspNetCore.Docs/tree/main/aspnetcore/mvc/views/view-components/sample6.x), build and test the starter code. It's a basic project with a `ToDo` controller that displays a list of *ToDo* items.
+[Download](https://github.com/dotnet/AspNetCore.Docs/tree/main/aspnetcore/mvc/views/view-components/sample6.x), build, and test the starter code. It's a basic project with a `ToDo` controller that displays a list of *ToDo* items.
 
 ![List of ToDos](view-components/_static/2dos.png)
 
@@ -185,8 +185,8 @@ Notes on the code:
      ```
 
 * The `[ViewComponent]` attribute in the preceding code tells the view component selector to use:
-  * The name `PriorityList` when looking for the views associated with the component
-  * The string "PriorityList" when referencing the class component from a view. 
+  * The name `PriorityList` when looking for the views associated with the component.
+  * The string "PriorityList" when referencing the class component from a view.
 * The component uses [dependency injection](../../fundamentals/dependency-injection.md) to make the data context available.
 * `InvokeAsync` exposes a method that can be called from a view, and it can take an arbitrary number of arguments.
 * The `InvokeAsync` method returns the set of `ToDo` items that satisfy the `isDone` and `maxPriority` parameters.
diff --git a/aspnetcore/mvc/views/working-with-forms.md b/aspnetcore/mvc/views/working-with-forms.md
index c4812c95d337..5eaa6ac57907 100644
--- a/aspnetcore/mvc/views/working-with-forms.md
+++ b/aspnetcore/mvc/views/working-with-forms.md
@@ -4,7 +4,7 @@ author: tdykstra
 description: Describes the built-in Tag Helpers used with Forms.
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 12/05/2019
+ms.date: 05/05/2026
 uid: mvc/views/working-with-forms
 ---
 # Tag Helpers in forms in ASP.NET Core
@@ -33,7 +33,7 @@ Sample:
 
 [!code-cshtml[](working-with-forms/sample/final/Views/Demo/RegisterFormOnly.cshtml)]
 
-The Form Tag Helper above generates the following HTML:
+The previous Form Tag Helper generates the following HTML:
 
 ```html
 <form method="post" action="/Demo/Register">
@@ -59,11 +59,11 @@ Many of the views in the *Views/Account* folder (generated when you create a new
 ```
 
 >[!NOTE]
->With the built in templates, `returnUrl` is only populated automatically when you try to access an authorized resource but are not authenticated or authorized. When you attempt an unauthorized access, the security middleware redirects you to the login page with the `returnUrl` set.
+>With the built in templates, `returnUrl` is only populated automatically when you try to access an authorized resource but aren't authenticated or authorized. When you attempt an unauthorized access, the security middleware redirects you to the login page with the `returnUrl` set.
 
 ## The Form Action Tag Helper
 
-The Form Action Tag Helper generates the `formaction` attribute on the generated `<button ...>` or `<input type="image" ...>` tag. The `formaction` attribute controls where a form submits its data. It binds to [\<input>](https://www.w3.org/wiki/HTML/Elements/input) elements of type `image` and [\<button>](https://www.w3.org/wiki/HTML/Elements/button) elements. The Form Action Tag Helper enables the usage of several [AnchorTagHelper](xref:mvc/views/tag-helpers/builtin-th/anchor-tag-helper) `asp-` attributes to control what `formaction` link is generated for the corresponding element.
+The Form Action Tag Helper generates the `formaction` attribute on the generated `<button ...>` or `<input type="image" ...>` tag. The `formaction` attribute controls where a form submits its data. It binds to [\<input>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input) elements of type `image` and [\<button>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/button) elements. The Form Action Tag Helper enables the usage of several [AnchorTagHelper](xref:mvc/views/tag-helpers/builtin-th/anchor-tag-helper) `asp-` attributes to control what `formaction` link is generated for the corresponding element.
 
 Supported [AnchorTagHelper](xref:mvc/views/tag-helpers/builtin-th/anchor-tag-helper) attributes to control the value of `formaction`:
 
@@ -81,7 +81,7 @@ Supported [AnchorTagHelper](xref:mvc/views/tag-helpers/builtin-th/anchor-tag-hel
 
 ### Submit to controller example
 
-The following markup submits the form to the `Index` action of `HomeController` when the input or button are selected:
+The following markup submits the form to the `Index` action of `HomeController` when the input or button is selected:
 
 ```cshtml
 <form method="post">
@@ -165,17 +165,17 @@ Syntax:
 
 The Input Tag Helper:
 
-* Generates the `id` and `name` HTML attributes for the expression name specified in the `asp-for` attribute. `asp-for="Property1.Property2"` is equivalent to `m => m.Property1.Property2`. The name of the expression is what is used for the `asp-for` attribute value. See the [Expression names](#expression-names) section for additional information.
+* Generates the `id` and `name` HTML attributes for the expression name specified in the `asp-for` attribute. `asp-for="Property1.Property2"` is equivalent to `m => m.Property1.Property2`. The name of the expression is what is used for the `asp-for` attribute value. For more information, see the [Expression names](#expression-names) section.
 
 * Sets the HTML `type` attribute value based on the model type and  [data annotation](xref:Microsoft.AspNetCore.Mvc.DataAnnotations.IAttributeAdapter) attributes applied to the model property
 
 * Won't overwrite the HTML `type` attribute value when one is specified
 
-* Generates [HTML5](https://developer.mozilla.org/docs/Web/Guide/HTML/HTML5)  validation attributes from [data annotation](xref:Microsoft.AspNetCore.Mvc.DataAnnotations.IAttributeAdapter) attributes applied to model properties
+* Generates [HTML5](https://developer.mozilla.org/docs/Glossary/HTML5)  validation attributes from [data annotation](xref:Microsoft.AspNetCore.Mvc.DataAnnotations.IAttributeAdapter) attributes applied to model properties
 
 * Has an HTML Helper feature overlap with `Html.TextBoxFor` and `Html.EditorFor`. See the [HTML Helper alternatives to Input Tag Helper](#html-helper-alternatives-to-input-tag-helper) section for details.
 
-* Provides strong typing. If the name of the property changes and you don't update the Tag Helper you'll get an error similar to the following:
+* Provides strong typing. If the name of the property changes and you don't update the Tag Helper, you'll get an error similar to the following:
 
   ```
   An error occurred during the compilation of a resource required to process
@@ -194,7 +194,7 @@ The `Input` Tag Helper sets the HTML `type` attribute based on the .NET type. Th
 |---|---|
 |Bool|type="checkbox"|
 |String|type="text"|
-|DateTime|type=["datetime-local"](https://developer.mozilla.org/docs/Web/HTML/Element/input/datetime-local)|
+|DateTime|type=["datetime-local"](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input/datetime-local)|
 |Byte|type="number"|
 |Int|type="number"|
 |Single, Double|type="number"|
@@ -217,7 +217,7 @@ Sample:
 
 [!code-cshtml[](working-with-forms/sample/final/Views/Demo/RegisterInput.cshtml)]
 
-The code above generates the following HTML:
+The preceding code generates the following HTML:
 
 ```html
 <form method="post" action="/Demo/RegisterInput">
@@ -237,7 +237,7 @@ The code above generates the following HTML:
 
 The data annotations applied to the `Email` and `Password` properties generate metadata on the model. The Input Tag Helper consumes the model metadata and produces [HTML5](https://developer.mozilla.org/docs/Web/Guide/HTML/HTML5) `data-val-*` attributes (see [Model Validation](../models/validation.md)). These attributes describe the validators to attach to the input fields. This provides unobtrusive HTML5 and [jQuery](https://jquery.com/) validation. The unobtrusive attributes have the format `data-val-rule="Error Message"`, where rule is the name of the validation rule (such as `data-val-required`, `data-val-email`, `data-val-maxlength`, etc.) If an error message is provided in the attribute, it's displayed as the value for the `data-val-rule` attribute. There are also attributes of the form `data-val-ruleName-argumentName="argumentValue"` that provide additional details about the rule, for example, `data-val-maxlength-max="1024"` .
 
-When binding multiple `input` controls to the same property, the generated controls share the same `id`, which makes the generated mark-up invalid. To prevent duplicates, specify the `id` attribute for each control explicitly. 
+When binding multiple `input` controls to the same property, the generated controls share the same `id`, which makes the generated mark-up invalid. To prevent duplicates, specify the `id` attribute for each control explicitly.
 
 ### Checkbox hidden input rendering
 
@@ -282,7 +282,7 @@ The preceding code disables hidden input rendering for checkboxes by setting `Ch
 
 ### HTML Helper alternatives to Input Tag Helper
 
-`Html.TextBox`, `Html.TextBoxFor`, `Html.Editor` and `Html.EditorFor` have overlapping features with the Input Tag Helper. The Input Tag Helper will automatically set the `type` attribute; `Html.TextBox` and `Html.TextBoxFor` won't. `Html.Editor` and `Html.EditorFor` handle collections, complex objects and templates; the Input Tag Helper doesn't. The Input Tag Helper, `Html.EditorFor`  and  `Html.TextBoxFor` are strongly typed (they use lambda expressions); `Html.TextBox` and `Html.Editor` are not (they use expression names).
+`Html.TextBox`, `Html.TextBoxFor`, `Html.Editor`, and `Html.EditorFor` have overlapping features with the Input Tag Helper. The Input Tag Helper will automatically set the `type` attribute; `Html.TextBox` and `Html.TextBoxFor` won't. `Html.Editor` and `Html.EditorFor` handle collections, complex objects, and templates; the Input Tag Helper doesn't. The Input Tag Helper, `Html.EditorFor`, and `Html.TextBoxFor` are strongly typed (they use lambda expressions); `Html.TextBox` and `Html.Editor` aren't (they use expression names).
 
 ### HtmlAttributes
 
@@ -295,7 +295,7 @@ The preceding code disables hidden input rendering for checkboxes by setting `Ch
 
 ### Expression names
 
-The `asp-for` attribute value is a `ModelExpression` and the right hand side of a lambda expression. Therefore, `asp-for="Property1"` becomes `m => m.Property1` in the generated code which is why you don't need to prefix with `Model`. You can use the "\@" character to start an inline expression and move before the `m.`:
+The `asp-for` attribute value is a `ModelExpression` and the right hand side of a lambda expression. Therefore, `asp-for="Property1"` becomes `m => m.Property1` in the generated code, which is why you don't need to prefix with `Model`. You can use the "\@" character to start an inline expression and move before the `m.`:
 
 ```cshtml
 @{
@@ -383,7 +383,7 @@ The `Views/Shared/EditorTemplates/ToDoItem.cshtml` template:
 
 The `Textarea Tag Helper` tag helper is  similar to the Input Tag Helper.
 
-* Generates the `id` and `name` attributes, and the data validation attributes from the model for a [\<textarea>](https://www.w3.org/wiki/HTML/Elements/textarea) element.
+* Generates the `id` and `name` attributes, and the data validation attributes from the model for a [\<textarea>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/textarea) element.
 
 * Provides strong typing.
 
@@ -413,7 +413,7 @@ The following HTML is generated:
 
 ## The Label Tag Helper
 
-* Generates the label caption and `for` attribute on a [\<label>](https://www.w3.org/wiki/HTML/Elements/label) element for an expression name
+* Generates the label caption and `for` attribute on a [\<label>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/label) element for an expression name
 
 * HTML Helper alternative: `Html.LabelFor`.
 
@@ -437,7 +437,7 @@ The following HTML is generated for the `<label>` element:
 <label for="Email">Email Address</label>
 ```
 
-The Label Tag Helper generated the `for` attribute value of "Email", which is the ID associated with the `<input>` element. The Tag Helpers generate consistent `id` and `for` elements so they can be correctly associated. The caption in this sample comes from the `Display` attribute. If the model didn't contain a `Display` attribute, the caption would be the property name of the expression.  To override the default caption, add a caption inside the label tag.
+The Label Tag Helper generated the `for` attribute value of "Email", which is the ID associated with the `<input>` element. The Tag Helpers generate consistent `id` and `for` elements so they can be correctly associated. The caption in this sample comes from the `Display` attribute. If the model didn't contain a `Display` attribute, the caption would be the property name of the expression. To override the default caption, add a caption inside the label tag.
 
 ## The Validation Tag Helpers
 
@@ -445,13 +445,13 @@ There are two Validation Tag Helpers. The `Validation Message Tag Helper` (which
 
 ### The Validation Message Tag Helper
 
-* Adds the [HTML5](https://developer.mozilla.org/docs/Web/Guide/HTML/HTML5)  `data-valmsg-for="property"` attribute to the [span](https://developer.mozilla.org/docs/Web/HTML/Element/span) element, which attaches the validation error messages on the input field of the specified model property. When a client side validation error occurs, [jQuery](https://jquery.com/) displays the error message in the `<span>` element.
+* Adds the [HTML5](https://developer.mozilla.org/docs/Web/Guide/HTML/HTML5)  `data-valmsg-for="property"` attribute to the [span](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/span) element, which attaches the validation error messages on the input field of the specified model property. When a client side validation error occurs, [jQuery](https://jquery.com/) displays the error message in the `<span>` element.
 
-* Validation also takes place on the server. Clients may have JavaScript disabled and some validation can only be done on the server side.
+* Validation also takes place on the server. Clients might have JavaScript disabled and some validation can only be done on the server side.
 
 * HTML Helper alternative: `Html.ValidationMessageFor`
 
-The `Validation Message Tag Helper`  is used with the `asp-validation-for` attribute on an HTML [span](https://developer.mozilla.org/docs/Web/HTML/Element/span) element.
+The `Validation Message Tag Helper`  is used with the `asp-validation-for` attribute on an HTML [span](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/span) element.
 
 ```cshtml
 <span asp-validation-for="Email"></span>
@@ -468,7 +468,7 @@ The Validation Message Tag Helper will generate the following HTML:
 You generally use the `Validation Message Tag Helper`  after an `Input` Tag Helper for the same property. Doing so displays any validation error messages near the input that caused the error.
 
 > [!NOTE]
-> You must have a view with the correct JavaScript and [jQuery](https://jquery.com/) script references in place for client side validation. See [Model Validation](../models/validation.md) for more information.
+> You must have a view with the correct JavaScript and [jQuery](https://jquery.com/) script references in place for client side validation. For more information, see [Model Validation](../models/validation.md).
 
 When a server side validation error occurs (for example when you have custom server side validation or client-side validation is disabled), MVC places that error message as the body of the `<span>` element.
 
@@ -495,7 +495,7 @@ The `Validation Summary Tag Helper`  is used to display a summary of validation
 
 ### Sample
 
-In the following example, the data model has `DataAnnotation` attributes, which generates validation error messages on the `<input>` element.  When a validation error occurs, the Validation Tag Helper displays the error message:
+In the following example, the data model has `DataAnnotation` attributes, which generates validation error messages on the `<input>` element. When a validation error occurs, the Validation Tag Helper displays the error message:
 
 [!code-csharp[](working-with-forms/sample/final/ViewModels/RegisterViewModel.cs)]
 
@@ -522,11 +522,11 @@ The generated HTML (when the model is valid):
 
 ## The Select Tag Helper
 
-* Generates [select](https://www.w3.org/wiki/HTML/Elements/select) and associated [option](https://www.w3.org/wiki/HTML/Elements/option) elements for properties of your model.
+* Generates [select](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/select) and associated [option](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/option) elements for properties of your model.
 
 * Has an HTML Helper alternative `Html.DropDownListFor` and `Html.ListBoxFor`
 
-The `Select Tag Helper` `asp-for` specifies the model property  name for the [select](https://www.w3.org/wiki/HTML/Elements/select) element  and `asp-items` specifies the [option](https://www.w3.org/wiki/HTML/Elements/option) elements.  For example:
+The `Select Tag Helper` `asp-for` specifies the model property  name for the [select](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/select) element  and `asp-items` specifies the [option](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/option) elements. For example:
 
 [!code-cshtml[](working-with-forms/sample/final/Views/Home/Index.cshtml?range=4)]
 
@@ -534,7 +534,7 @@ Sample:
 
 [!code-csharp[](working-with-forms/sample/final/ViewModels/CountryViewModel.cs)]
 
-The `Index` method initializes the `CountryViewModel`, sets the selected country and passes it to the `Index` view.
+The `Index` method initializes the `CountryViewModel`, sets the selected country, and passes it to the `Index` view.
 
 [!code-csharp[](working-with-forms/sample/final/Controllers/HomeController.cs?range=8-13)]
 
@@ -561,9 +561,9 @@ Which generates the following HTML (with "CA" selected):
 ```
 
 > [!NOTE]
-> We don't recommend using `ViewBag` or `ViewData` with the Select Tag Helper. A view model is more robust at providing MVC metadata and generally less problematic.
+> We don't recommend using `ViewBag` or `ViewData` with the Select Tag Helper. A view model is more robust at providing MVC metadata and less problematic.
 
-The `asp-for` attribute value is a special case and doesn't require a `Model` prefix, the other Tag Helper attributes do (such as `asp-items`)
+The `asp-for` attribute value is a special case and doesn't require a `Model` prefix. The other Tag Helper attributes do (such as `asp-items`).
 
 [!code-cshtml[](working-with-forms/sample/final/Views/Home/Index.cshtml?range=4)]
 
@@ -605,13 +605,13 @@ The following HTML is generated:
 
 ### Option Group
 
-The HTML  [\<optgroup>](https://www.w3.org/wiki/HTML/Elements/optgroup) element is generated when the view model contains one or more `SelectListGroup` objects.
+The HTML  [\<optgroup>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/optgroup) element is generated when the view model contains one or more `SelectListGroup` objects.
 
 The `CountryViewModelGroup` groups the `SelectListItem` elements into the "North America" and "Europe" groups:
 
 [!code-csharp[](../../mvc/views/working-with-forms/sample/final/ViewModels/CountryViewModelGroup.cs?highlight=5,6,14,20,26,32,38,44&range=6-56)]
 
-The two groups are shown below:
+The two groups are shown as follows:
 
 ![option group example](working-with-forms/_static/grp.png)
 
@@ -674,13 +674,13 @@ The `Views/Shared/EditorTemplates/CountryViewModel.cshtml` template:
 
 [!code-cshtml[](working-with-forms/sample/final/Views/Shared/EditorTemplates/CountryViewModel.cshtml)]
 
-Adding HTML [\<option>](https://www.w3.org/wiki/HTML/Elements/option) elements isn't limited to the *No selection* case. For example, the following view and action method will generate HTML similar to the code above:
+Adding HTML [\<option>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/option) elements isn't limited to the *No selection* case. For example, the following view and action method will generate HTML similar to the preceding code:
 
 [!code-csharp[](working-with-forms/sample/final/Controllers/HomeController.cs?name=snippetNone)]
 
 [!code-cshtml[](working-with-forms/sample/final/Views/Home/IndexOption.cshtml)]
 
-The correct `<option>` element will be selected ( contain the `selected="selected"` attribute) depending on the current `Country` value.
+The correct `<option>` element will be selected (contain the `selected="selected"` attribute) depending on the current `Country` value.
 
 [!code-csharp[](working-with-forms/sample/final/Controllers/HomeController.cs?range=114-119)]
 

From 518a3f0d1676f05bec64fad04cfa2922b5ad79cc Mon Sep 17 00:00:00 2001
From: lootle1 <175976130+lootle1@users.noreply.github.com>
Date: Wed, 6 May 2026 10:44:04 -0500
Subject: [PATCH 3/3] Edits2

---
 aspnetcore/mvc/views/working-with-forms.md | 32 +++++++++++-----------
 aspnetcore/test/hot-reload.md              |  2 +-
 aspnetcore/web-api/index.md                | 10 +++----
 3 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/aspnetcore/mvc/views/working-with-forms.md b/aspnetcore/mvc/views/working-with-forms.md
index 5eaa6ac57907..c6d7013038fd 100644
--- a/aspnetcore/mvc/views/working-with-forms.md
+++ b/aspnetcore/mvc/views/working-with-forms.md
@@ -13,7 +13,7 @@ By [Rick Anderson](https://twitter.com/RickAndMSFT), [N. Taylor Mullen](https://
 
 This document demonstrates working with Forms and the HTML elements commonly used on a Form. The HTML [Form](https://www.w3.org/TR/html401/interact/forms.html) element provides the primary mechanism web apps use to post back data to the server. Most of this document describes [Tag Helpers](tag-helpers/intro.md) and how they can help you productively create robust HTML forms. We recommend you read [Introduction to Tag Helpers](tag-helpers/intro.md) before you read this document.
 
-In many cases, HTML Helpers provide an alternative approach to a specific Tag Helper, but it's important to recognize that Tag Helpers don't replace HTML Helpers and there's not a Tag Helper for each HTML Helper. When an HTML Helper alternative exists, it's mentioned.
+In many cases, HTML Helpers provide an alternative approach to a specific Tag Helper. However, it's important to recognize that Tag Helpers don't replace HTML Helpers, and there's not a Tag Helper for each HTML Helper. When an HTML Helper alternative exists, it's mentioned.
 
 <a name="my-asp-route-param-ref-label"></a>
 
@@ -21,13 +21,13 @@ In many cases, HTML Helpers provide an alternative approach to a specific Tag He
 
 The [Form Tag Helper](xref:Microsoft.AspNetCore.Mvc.TagHelpers.FormTagHelper):
 
-* Generates the HTML [\<FORM>](https://www.w3.org/TR/html401/interact/forms.html) `action` attribute value for a MVC controller action or named route
+* Generates the HTML [\<FORM>](https://www.w3.org/TR/html401/interact/forms.html) `action` attribute value for a MVC controller action or named route.
 
-* Generates a hidden [Request Verification Token](/aspnet/mvc/overview/security/xsrfcsrf-prevention-in-aspnet-mvc-and-web-pages) to prevent cross-site request forgery (when used with the `[ValidateAntiForgeryToken]` attribute in the HTTP Post action method)
+* Generates a hidden [Request Verification Token](/aspnet/mvc/overview/security/xsrfcsrf-prevention-in-aspnet-mvc-and-web-pages) to prevent cross-site request forgery (when used with the `[ValidateAntiForgeryToken]` attribute in the HTTP Post action method).
 
 * Provides the `asp-route-<Parameter Name>` attribute, where `<Parameter Name>` is added to the route values. The  `routeValues` parameters to `Html.BeginForm` and `Html.BeginRouteForm` provide similar functionality.
 
-* Has an HTML Helper alternative `Html.BeginForm` and `Html.BeginRouteForm`
+* Has an HTML Helper alternative `Html.BeginForm` and `Html.BeginRouteForm`.
 
 Sample:
 
@@ -42,7 +42,7 @@ The previous Form Tag Helper generates the following HTML:
 </form>
 ```
 
-The MVC runtime generates the `action` attribute value from the Form Tag Helper attributes `asp-controller` and `asp-action`. The Form Tag Helper also generates a hidden [Request Verification Token](/aspnet/mvc/overview/security/xsrfcsrf-prevention-in-aspnet-mvc-and-web-pages) to prevent cross-site request forgery (when used with the `[ValidateAntiForgeryToken]` attribute in the HTTP Post action method). Protecting a pure HTML Form from cross-site request forgery is difficult, the Form Tag Helper provides this service for you.
+The MVC runtime generates the `action` attribute value from the Form Tag Helper attributes `asp-controller` and `asp-action`. The Form Tag Helper also generates a hidden [Request Verification Token](/aspnet/mvc/overview/security/xsrfcsrf-prevention-in-aspnet-mvc-and-web-pages) to prevent cross-site request forgery (when used with the `[ValidateAntiForgeryToken]` attribute in the HTTP Post action method). Protecting a pure HTML Form from cross-site request forgery is difficult, but the Form Tag Helper provides this service for you.
 
 ### Using a named route
 
@@ -167,11 +167,11 @@ The Input Tag Helper:
 
 * Generates the `id` and `name` HTML attributes for the expression name specified in the `asp-for` attribute. `asp-for="Property1.Property2"` is equivalent to `m => m.Property1.Property2`. The name of the expression is what is used for the `asp-for` attribute value. For more information, see the [Expression names](#expression-names) section.
 
-* Sets the HTML `type` attribute value based on the model type and  [data annotation](xref:Microsoft.AspNetCore.Mvc.DataAnnotations.IAttributeAdapter) attributes applied to the model property
+* Sets the HTML `type` attribute value based on the model type and  [data annotation](xref:Microsoft.AspNetCore.Mvc.DataAnnotations.IAttributeAdapter) attributes applied to the model property.
 
-* Won't overwrite the HTML `type` attribute value when one is specified
+* Won't overwrite the HTML `type` attribute value when one is specified.
 
-* Generates [HTML5](https://developer.mozilla.org/docs/Glossary/HTML5)  validation attributes from [data annotation](xref:Microsoft.AspNetCore.Mvc.DataAnnotations.IAttributeAdapter) attributes applied to model properties
+* Generates [HTML5](https://developer.mozilla.org/docs/Glossary/HTML5)  validation attributes from [data annotation](xref:Microsoft.AspNetCore.Mvc.DataAnnotations.IAttributeAdapter) attributes applied to model properties.
 
 * Has an HTML Helper feature overlap with `Html.TextBoxFor` and `Html.EditorFor`. See the [HTML Helper alternatives to Input Tag Helper](#html-helper-alternatives-to-input-tag-helper) section for details.
 
@@ -235,7 +235,7 @@ The preceding code generates the following HTML:
 </form>
 ```
 
-The data annotations applied to the `Email` and `Password` properties generate metadata on the model. The Input Tag Helper consumes the model metadata and produces [HTML5](https://developer.mozilla.org/docs/Web/Guide/HTML/HTML5) `data-val-*` attributes (see [Model Validation](../models/validation.md)). These attributes describe the validators to attach to the input fields. This provides unobtrusive HTML5 and [jQuery](https://jquery.com/) validation. The unobtrusive attributes have the format `data-val-rule="Error Message"`, where rule is the name of the validation rule (such as `data-val-required`, `data-val-email`, `data-val-maxlength`, etc.) If an error message is provided in the attribute, it's displayed as the value for the `data-val-rule` attribute. There are also attributes of the form `data-val-ruleName-argumentName="argumentValue"` that provide additional details about the rule, for example, `data-val-maxlength-max="1024"` .
+The data annotations applied to the `Email` and `Password` properties generate metadata on the model. The Input Tag Helper consumes the model metadata and produces [HTML5](https://developer.mozilla.org/docs/Web/Guide/HTML/HTML5) `data-val-*` attributes (see [Model Validation](../models/validation.md)). These attributes describe the validators to attach to the input fields. This provides unobtrusive HTML5 and [jQuery](https://jquery.com/) validation. The unobtrusive attributes have the format `data-val-rule="Error Message"`, where rule is the name of the validation rule (such as `data-val-required`, `data-val-email`, `data-val-maxlength`, etc.). If an error message is provided in the attribute, it's displayed as the value for the `data-val-rule` attribute. There are also attributes of the form `data-val-ruleName-argumentName="argumentValue"` that provide additional details about the rule, for example, `data-val-maxlength-max="1024"` .
 
 When binding multiple `input` controls to the same property, the generated controls share the same `id`, which makes the generated mark-up invalid. To prevent duplicates, specify the `id` attribute for each control explicitly.
 
@@ -387,7 +387,7 @@ The `Textarea Tag Helper` tag helper is  similar to the Input Tag Helper.
 
 * Provides strong typing.
 
-* HTML Helper alternative: `Html.TextAreaFor`
+* HTML Helper alternative: `Html.TextAreaFor`.
 
 Sample:
 
@@ -413,7 +413,7 @@ The following HTML is generated:
 
 ## The Label Tag Helper
 
-* Generates the label caption and `for` attribute on a [\<label>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/label) element for an expression name
+* Generates the label caption and `for` attribute on a [\<label>](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/label) element for an expression name.
 
 * HTML Helper alternative: `Html.LabelFor`.
 
@@ -421,7 +421,7 @@ The `Label Tag Helper`  provides the following benefits over a pure HTML label e
 
 * You automatically get the descriptive label value from the `Display` attribute. The intended display name might change over time, and the combination of `Display` attribute and Label Tag Helper will apply the `Display` everywhere it's used.
 
-* Less markup in source code
+* Less markup in source code.
 
 * Strong typing with the model property.
 
@@ -449,7 +449,7 @@ There are two Validation Tag Helpers. The `Validation Message Tag Helper` (which
 
 * Validation also takes place on the server. Clients might have JavaScript disabled and some validation can only be done on the server side.
 
-* HTML Helper alternative: `Html.ValidationMessageFor`
+* HTML Helper alternative: `Html.ValidationMessageFor`.
 
 The `Validation Message Tag Helper`  is used with the `asp-validation-for` attribute on an HTML [span](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/span) element.
 
@@ -481,9 +481,9 @@ When a server side validation error occurs (for example when you have custom ser
 
 ### The Validation Summary Tag Helper
 
-* Targets `<div>` elements with the `asp-validation-summary` attribute
+* Targets `<div>` elements with the `asp-validation-summary` attribute.
 
-* HTML Helper alternative: `@Html.ValidationSummary`
+* HTML Helper alternative: `@Html.ValidationSummary`.
 
 The `Validation Summary Tag Helper`  is used to display a summary of validation messages. The `asp-validation-summary` attribute value can be any of the following:
 
@@ -524,7 +524,7 @@ The generated HTML (when the model is valid):
 
 * Generates [select](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/select) and associated [option](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/option) elements for properties of your model.
 
-* Has an HTML Helper alternative `Html.DropDownListFor` and `Html.ListBoxFor`
+* Has an HTML Helper alternative `Html.DropDownListFor` and `Html.ListBoxFor`.
 
 The `Select Tag Helper` `asp-for` specifies the model property  name for the [select](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/select) element  and `asp-items` specifies the [option](https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/option) elements. For example:
 
diff --git a/aspnetcore/test/hot-reload.md b/aspnetcore/test/hot-reload.md
index 5ddd59a56e01..b27d6de20aa6 100644
--- a/aspnetcore/test/hot-reload.md
+++ b/aspnetcore/test/hot-reload.md
@@ -5,7 +5,7 @@ description: Use .NET Hot Reload to apply code changes to a running app without
 monikerRange: '>= aspnetcore-6.0'
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 11/10/2022
+ms.date: 05/05/2026
 uid: test/hot-reload
 ---
 # .NET Hot Reload support for ASP.NET Core
diff --git a/aspnetcore/web-api/index.md b/aspnetcore/web-api/index.md
index e499142bcc09..9ad04e865c01 100644
--- a/aspnetcore/web-api/index.md
+++ b/aspnetcore/web-api/index.md
@@ -5,7 +5,7 @@ description: Learn the basics of creating a web API in ASP.NET Core.
 monikerRange: '>= aspnetcore-2.1'
 ms.author: tdykstra
 ms.custom: mvc
-ms.date: 05/29/2024
+ms.date: 05/06/2026
 uid: web-api/index
 ---
 # Create web APIs with ASP.NET Core
@@ -136,7 +136,7 @@ The default response type for an HTTP 400 response is <xref:Microsoft.AspNetCore
 The `ValidationProblemDetails` type:
 
 * Provides a machine-readable format for specifying errors in web API responses.
-* Complies with the [RFC 7807 specification](https://tools.ietf.org/html/rfc7807).
+* Complies with the [RFC 7807 specification](https://datatracker.ietf.org/doc/html/rfc7807).
 
 To make automatic and custom responses consistent, call the <xref:Microsoft.AspNetCore.Mvc.ControllerBase.ValidationProblem%2A> method instead of <xref:Microsoft.AspNetCore.Mvc.ControllerBase.BadRequest%2A>. `ValidationProblem` returns a <xref:Microsoft.AspNetCore.Mvc.ValidationProblemDetails> object as well as the automatic response.
 
@@ -254,7 +254,7 @@ To disable the default behavior, set the <xref:Microsoft.AspNetCore.Mvc.ApiBehav
 
 ## Problem details for error status codes
 
-MVC transforms an error result (a result with status code 400 or higher) to a result with <xref:Microsoft.AspNetCore.Mvc.ProblemDetails>. The `ProblemDetails` type is based on the [RFC 7807 specification](https://tools.ietf.org/html/rfc7807) for providing machine-readable error details in an HTTP response.
+MVC transforms an error result (a result with status code 400 or higher) to a result with <xref:Microsoft.AspNetCore.Mvc.ProblemDetails>. The `ProblemDetails` type is based on the [RFC 7807 specification](https://datatracker.ietf.org/doc/html/rfc7807) for providing machine-readable error details in an HTTP response.
 
 Consider the following code in a controller action:
 
@@ -291,7 +291,7 @@ The [[Consumes]](xref:Microsoft.AspNetCore.Mvc.ConsumesAttribute) attribute allo
 public IActionResult CreateProduct(Product product)
 ```
 
-In the preceding code, the `CreateProduct` action specifies the content type `application/xml`. Requests routed to this action must specify a `Content-Type` header of `application/xml`. Requests that don't specify a `Content-Type` header of `application/xml` result in a [415 Unsupported Media Type](https://developer.mozilla.org/docs/Web/HTTP/Status/415) response.
+In the preceding code, the `CreateProduct` action specifies the content type `application/xml`. Requests routed to this action must specify a `Content-Type` header of `application/xml`. Requests that don't specify a `Content-Type` header of `application/xml` result in a [415 Unsupported Media Type](https://developer.mozilla.org/docs/Web/HTTP/Reference/Status/415) response.
 
 The `[Consumes]` attribute also allows an action to influence its selection based on an incoming request's content type by applying a type constraint. Consider the following example:
 
@@ -299,7 +299,7 @@ The `[Consumes]` attribute also allows an action to influence its selection base
 
 In the preceding code, `ConsumesController` is configured to handle requests sent to the `https://localhost:5001/api/Consumes` URL. Both of the controller's actions, `PostJson` and `PostForm`, handle POST requests with the same URL. Without the `[Consumes]` attribute applying a type constraint, an ambiguous match exception is thrown.
 
-The `[Consumes]` attribute is applied to both actions. The `PostJson` action handles requests sent with a `Content-Type` header of `application/json`. The `PostForm` action handles requests sent with a `Content-Type` header of `application/x-www-form-urlencoded`. 
+The `[Consumes]` attribute is applied to both actions. The `PostJson` action handles requests sent with a `Content-Type` header of `application/json`. The `PostForm` action handles requests sent with a `Content-Type` header of `application/x-www-form-urlencoded`.
 
 ## Additional resources