Freshness pass for Q2FY26: Update 44 .NET Fundamentals articles with style improvements and current dates

docs/core/get-started.md

@@ -3,9 +3,10 @@ title: Get started with .NET
 description: Create a Hello World .NET app.
 author: adegeo
 ms.author: adegeo
-ms.date: 07/19/2022
+ms.date: 10/21/2025
 ms.custom: vs-dotnet, devdivchpfy22
 ms.topic: tutorial
+ai-usage: ai-assisted
 ---
 # Get started with .NET
 
@@ -17,15 +18,15 @@ First, download and install the [.NET SDK](https://dotnet.microsoft.com/download
 
 Next, open a terminal such as **PowerShell**, **Command Prompt**, or **bash**.
 
-Type the following commands:
+Type these commands:
 
 ```dotnetcli
 dotnet new console -o sample1
 cd sample1
 dotnet run
 ```
 
-You should see the following output:
+You should see this output:
 
 ```output
 Hello World!
@@ -35,4 +36,4 @@ Congratulations! You've created a simple .NET application.
 
 ## Next steps
 
-Get started on developing .NET applications by following a [step-by-step tutorial](../standard/get-started.md) or by watching [.NET 101 videos](https://www.youtube.com/playlist?list=PLdo4fOcmZ0oWoazjhXQzBKMrFuArxpW80) on YouTube.
+Get started developing .NET applications by following a [step-by-step tutorial](../standard/get-started.md) or by watching [.NET 101 videos](https://www.youtube.com/playlist?list=PLdo4fOcmZ0oWoazjhXQzBKMrFuArxpW80) on YouTube.

docs/core/tutorials/index.md

@@ -1,13 +1,14 @@
 ---
 title: .NET Tutorials
 description: Follow tutorials for learning .NET to build apps and libraries on Mac, Linux, and Windows.
-ms.date: 06/22/2022
+ms.date: 10/21/2025
 ms.custom: devdivchpfy22
 titleSuffix: ""
+ai-usage: ai-assisted
 ---
 # Learn .NET and the .NET SDK tools by exploring these tutorials
 
-The following tutorials show how to develop console apps and libraries for .NET Core, .NET 5, and later versions. For other types of applications, see [Tutorials for getting started with .NET](../../standard/get-started.md).
+These tutorials show how to develop console apps and libraries for .NET Core, .NET 5, and later versions. For other types of applications, see [Tutorials for getting started with .NET](../../standard/get-started.md).
 
 ## Use Visual Studio
 
@@ -22,7 +23,7 @@ The following tutorials show how to develop console apps and libraries for .NET
 
 ## Use Visual Studio Code
 
-Choose these tutorials if you want to use Visual Studio Code or some other code editor. All of them use the CLI for .NET Core development tasks, so all except the debugging tutorial can be used with any code editor.
+Choose these tutorials if you want to use Visual Studio Code or another code editor. All of them use the CLI for .NET Core development tasks, so all except the debugging tutorial can be used with any code editor.
 
 - [Create a console app](with-visual-studio-code.md)
 - [Debug an app](debugging-with-visual-studio-code.md)

docs/standard/assembly/index.md

@@ -1,7 +1,7 @@
 ---
 title: "Assemblies in .NET"
 description: Assemblies are fundamental units of deployment, version control, reuse, activation scoping, and security permissions for .NET-based applications.
-ms.date: 07/27/2022
+ms.date: 10/21/2025
 ms.custom: devdivchpfy22
 ms.assetid: 149f5ca5-5b34-4746-9542-1ae43b2d0256
 helpviewer_keywords:
@@ -14,6 +14,7 @@ helpviewer_keywords:
   - "assemblies [.NET Framework]"
   - "version boundaries"
   - "type boundaries"
+ai-usage: ai-assisted
 ---
 
 # Assemblies in .NET
@@ -26,13 +27,13 @@ Assemblies have the following properties:
 
 - Assemblies are implemented as *.exe* or *.dll* files.
 
-- For libraries that target .NET Framework, you can share assemblies between applications by putting them in the [global assembly cache (GAC)](../../framework/app-domains/gac.md). You must strong-name assemblies before you can include them in the GAC. For more information, see [Strong-named assemblies](strong-named.md).
+- For libraries that target .NET Framework, you can share assemblies between applications by putting them in the [global assembly cache (GAC)](../../framework/app-domains/gac.md). Strong-name assemblies before you can include them in the GAC. For more information, see [Strong-named assemblies](strong-named.md).
 
 - Assemblies are only loaded into memory if they're required. If they aren't used, they aren't loaded. Therefore, assemblies can be an efficient way to manage resources in larger projects.
 
-- You can programmatically obtain information about an assembly by using reflection. For more information, see [Reflection (C#)](../../csharp/advanced-topics/reflection-and-attributes/index.md) or [Reflection (Visual Basic)](../../visual-basic/programming-guide/concepts/reflection.md).
+- You can programmatically obtain information about an assembly using reflection. For more information, see [Reflection (C#)](../../csharp/advanced-topics/reflection-and-attributes/index.md) or [Reflection (Visual Basic)](../../visual-basic/programming-guide/concepts/reflection.md).
 
-- You can load an assembly just to inspect it by using the <xref:System.Reflection.MetadataLoadContext> class on .NET and .NET Framework. <xref:System.Reflection.MetadataLoadContext> replaces the <xref:System.Reflection.Assembly.ReflectionOnlyLoad%2A?displayProperty=nameWithType> methods.
+- You can load an assembly just to inspect it using the <xref:System.Reflection.MetadataLoadContext> class on .NET and .NET Framework. <xref:System.Reflection.MetadataLoadContext> replaces the <xref:System.Reflection.Assembly.ReflectionOnlyLoad%2A?displayProperty=nameWithType> methods.
 
 ## Assemblies in the common language runtime
 
@@ -56,7 +57,7 @@ An assembly defines the following information:
 
 ## Create an assembly
 
-Assemblies can be static or dynamic. Static assemblies are stored on a disk in portable executable (PE) files. Static assemblies can include interfaces, classes, and resources like bitmaps, JPEG files, and other resource files. You can also create dynamic assemblies, which are run directly from memory and aren't saved to disk before execution. You can save dynamic assemblies to disk after they've been executed.
+Assemblies can be static or dynamic. Static assemblies are stored on a disk in portable executable (PE) files. Static assemblies can include interfaces, classes, and resources like bitmaps, JPEG files, and other resource files. You can also create dynamic assemblies, which run directly from memory and aren't saved to disk before execution. You can save dynamic assemblies to disk after they've been executed.
 
 There are several ways to create assemblies. You can use development tools, such as Visual Studio that can create *.dll* or *.exe* files. You can use tools in the Windows SDK to create assemblies with modules from other development environments. You can also use common language runtime APIs, such as <xref:System.Reflection.Emit?displayProperty=nameWithType>, to create dynamic assemblies.
 
@@ -82,10 +83,10 @@ Assemblies contain information about content, versioning, and dependencies. So t
 To use an assembly in an application, you must add a reference to it. When an assembly is referenced, all the accessible types, properties, methods, and other members of its namespaces are available to your application as if their code were part of your source file.
 
 > [!NOTE]
-> Most assemblies from the .NET Class Library are referenced automatically. If a system assembly isn't automatically referenced, add a reference in one of the following ways:
+> Most assemblies from the .NET Class Library are referenced automatically. If a system assembly isn't automatically referenced, add a reference in one of these ways:
 >
 > - For .NET and .NET Core, add a reference to the NuGet package that contains the assembly. Either use the NuGet Package Manager in Visual Studio or add a [\<PackageReference>](../../core/tools/dependencies.md#the-packagereference-element) element for the assembly to the *.csproj* or *.vbproj* project.
-> - For .NET Framework, add a reference to the assembly by using the **Add Reference** dialog in Visual Studio or the `-reference` command line option for the [C#](../../csharp/language-reference/compiler-options/inputs.md#references) or [Visual Basic](../../visual-basic/reference/command-line-compiler/reference.md) compilers.
+> - For .NET Framework, add a reference to the assembly using the **Add Reference** dialog in Visual Studio or the `-reference` command line option for the [C#](../../csharp/language-reference/compiler-options/inputs.md#references) or [Visual Basic](../../visual-basic/reference/command-line-compiler/reference.md) compilers.
 
 In C#, you can use two versions of the same assembly in a single application. For more information, see [extern alias](../../csharp/language-reference/keywords/extern-alias.md).
 

docs/standard/clr.md

@@ -2,7 +2,7 @@
 title: "Common Language Runtime (CLR) overview - .NET"
 titleSuffix: ""
 description: Get started with common language runtime (CLR), .NET's run-time environment. The CLR runs code and provides services to make the development process easier.
-ms.date: 07/26/2022
+ms.date: 10/21/2025
 ms.custom: devdivchpfy22
 helpviewer_keywords: 
   - "compiling source code, runtime functionality"
@@ -17,6 +17,7 @@ helpviewer_keywords:
   - "source code execution"
   - "code, runtime functionality"
 ms.assetid: 059a624e-f7db-4134-ba9f-08b676050482
+ai-usage: ai-assisted
 ---
 # Common Language Runtime (CLR) overview
 
@@ -29,13 +30,13 @@ Compilers and tools expose the common language runtime's functionality and enabl
 
 To enable the runtime to provide services to managed code, language compilers must emit metadata that describes the types, members, and references in your code. Metadata is stored with the code; every loadable common language runtime portable executable (PE) file contains metadata. The runtime uses metadata to locate and load classes, lay out instances in memory, resolve method invocations, generate native code, enforce security, and set run-time context boundaries.
 
-The runtime automatically handles object layout and manages references to objects, releasing them when they're no longer being used. Objects whose lifetimes are managed in this way are called managed data. Garbage collection eliminates memory leaks and some other common programming errors. If your code is managed, you can use managed, unmanaged, or both managed and unmanaged data in your .NET application. Because language compilers supply their own types, such as primitive types, you might not always know or need to know whether your data is being managed.
+The runtime automatically handles object layout and manages references to objects, releasing them when they're no longer being used. Objects whose lifetimes are managed this way are called managed data. Garbage collection eliminates memory leaks and some other common programming errors. If your code is managed, you can use managed data, unmanaged data, or both in your .NET application. Because language compilers supply their own types, such as primitive types, you might not always know or need to know whether your data is being managed.
 
 The common language runtime makes it easy to design components and applications whose objects interact across languages. Objects written in different languages can communicate with each other, and their behaviors can be tightly integrated. For example, you can define a class and then use a different language to derive a class from your original class or call a method on the original class. You can also pass an instance of a class to a method of a class written in a different language. This cross-language integration is possible because language compilers and tools that target the runtime use a common type system defined by the runtime. They follow the runtime's rules for defining new types and for creating, using, persisting, and binding to types.
 
 As part of their metadata, all managed components carry information about the components and resources they were built against. The runtime uses this information to ensure that your component or application has the specified versions of everything it needs, which makes your code less likely to break because of some unmet dependency. Registration information and state data are no longer stored in the registry, where they can be difficult to establish and maintain. Instead, information about the types you define and their dependencies is stored with the code as metadata. This way, the task of component replication and removal is less complicated.
 
-Language compilers and tools expose the runtime's functionality in ways that are intended to be useful and intuitive to developers. Some features of the runtime might be more noticeable in one environment than in another. How you experience the runtime depends on which language compilers or tools you use. For example, if you're a Visual Basic developer, you might notice that with the common language runtime, the Visual Basic language has more object-oriented features than before. The runtime provides the following benefits:
+Language compilers and tools expose the runtime's functionality in ways that are intended to be useful and intuitive to developers. Some features of the runtime might be more noticeable in one environment than in another. How you experience the runtime depends on which language compilers or tools you use. For example, if you're a Visual Basic developer, you might notice that with the common language runtime, the Visual Basic language has more object-oriented features than before. The runtime provides these benefits:
 
 - Performance improvements.
 
@@ -59,7 +60,7 @@ Language compilers and tools expose the runtime's functionality in ways that are
 
 .NET Core and .NET 5+ releases have a single product version, that is, there's no separate CLR version. For a list of .NET Core versions, see [Download .NET Core](https://dotnet.microsoft.com/download/dotnet).
 
-However, the .NET Framework version number doesn't necessarily correspond to the version number of the CLR it includes. For a list of .NET Framework versions and their corresponding CLR versions, see [.NET Framework versions and dependencies](../framework/install/versions-and-dependencies.md).
+However, .NET Framework version number doesn't necessarily correspond to the version number of the CLR it includes. For a list of .NET Framework versions and their corresponding CLR versions, see [.NET Framework versions and dependencies](../framework/install/versions-and-dependencies.md).
 
 ## Related articles
 

docs/standard/collections/thread-safe/index.md

@@ -1,14 +1,15 @@
 ---
 title: Thread-Safe collections
 description: Get started with thread-safe collections using the System.Collections.Concurrent namespace in .NET, which includes thread-safe and scalable collection classes.
-ms.date: 01/23/2023
+ms.date: 10/21/2025
 ms.custom: devdivchpfy22
 helpviewer_keywords:
   - "thread-safe collections, overview"
+ai-usage: ai-assisted
 ---
 # Thread-safe collections
 
-The <xref:System.Collections.Concurrent?displayProperty=nameWithType> namespace includes several collection classes that are both thread-safe and scalable. Multiple threads can safely and efficiently add or remove items from these collections, without requiring additional synchronization in user code. When you write new code, use the concurrent collection classes to write multiple threads to the collection concurrently. If you're only reading from a shared collection, then you can use the classes in the <xref:System.Collections.Generic?displayProperty=nameWithType> namespace.
+The <xref:System.Collections.Concurrent?displayProperty=nameWithType> namespace includes several collection classes that are both thread-safe and scalable. Multiple threads can safely and efficiently add or remove items from these collections, without requiring additional synchronization in user code. When you write new code, use the concurrent collection classes to write multiple threads to the collection concurrently. If you're only reading from a shared collection, use the classes in the <xref:System.Collections.Generic?displayProperty=nameWithType> namespace.
 
 ## System.Collections and System.Collections.Generic
 
@@ -27,7 +28,7 @@ The <xref:System.Collections.Concurrent?displayProperty=nameWithType> namespace
 > [!NOTE]
 > Because the concurrent collections classes support <xref:System.Collections.ICollection>, they provide implementations for the <xref:System.Collections.ICollection.IsSynchronized%2A> and <xref:System.Collections.ICollection.SyncRoot%2A> properties, even though these properties are irrelevant. `IsSynchronized` always returns `false` and, `SyncRoot` is always `null` (`Nothing` in Visual Basic).
 
- The following table lists the collection types in the <xref:System.Collections.Concurrent?displayProperty=nameWithType> namespace:
+The following table lists the collection types in the <xref:System.Collections.Concurrent?displayProperty=nameWithType> namespace:
 
 |Type|Description|
 |----------|-----------------|

docs/standard/commandline/index.md

@@ -1,13 +1,14 @@
 ---
 title: System.CommandLine overview
 description: "Learn how to develop and use command-line apps that are based on the System.CommandLine library."
-ms.date: 04/07/2022
+ms.date: 10/21/2025
 no-loc: [System.CommandLine]
 helpviewer_keywords:
   - "command line interface"
   - "command line"
   - "System.CommandLine"
 ms.topic: overview
+ai-usage: ai-assisted
 ---
 
 # System.CommandLine overview
@@ -35,12 +36,12 @@ The library is available as a NuGet package: [System.CommandLine](https://www.nu
 
 ## Next steps
 
-To get started with System.CommandLine, see the following resources:
+To get started with System.CommandLine, see these resources:
 
 - [Tutorial: Get started with System.CommandLine](get-started-tutorial.md)
 - [Syntax overview: commands, options, and arguments](syntax.md)
 
-To learn more, see the following resources:
+To learn more, see these resources:
 
 - [How to parse and invoke the result](how-to-parse-and-invoke.md)
 - [How to customize parsing and validation](how-to-customize-parsing-and-validation.md)