Merge main into live

docs/azure/migration/appmod/containerization.md

@@ -30,19 +30,25 @@ The GitHub Copilot app modernization for .NET containerization feature helps you
 
 1. Open your project in Visual Studio.
 
-1. Enable **appModernizationDeploy** in the GitHub Copilot toolbox.
+1. Run App Assessment and open the Assessment Report.
+
+1. Fix the cloud readiness issues before running the **Docker Containerization** task.
+
+1. Make sure you enable **appModernizationDeploy** in the GitHub Copilot toolbox.
 
     :::image type="content" source="../../media/appmod-dotnet-containerization-tool-selection.png" alt-text="Screenshot that shows containerization tool selection.":::
 
-1. Start containerization by using one of these approaches:
+1. Start containerization by using one of the following approaches:
 
-    - **Containerize from Assessment Report**: In the assessment report, select **Run Task** for the Docker Containerization issue.
+    - **Containerize from Assessment Report**: In the assessment report, select **Run Task** for the Docker Containerization task.
 
         :::image type="content" source="media/containerize-assessment-report.png" alt-text="Screenshot that shows containerization task in assessment report.":::
 
     - **Use a containerization prompt**: You can input the following prompt in Copilot chat to containerize your project:
 
-        *Scan my project and help me plan how to containerize my application using the #appmod-get-containerization-plan tool. Execute the plan. The end goal is to have Dockerfiles that are able to be built.*
+        *Inspect my project and help me plan how to containerize my application using the #appmod-get-containerization-plan tool.
+        Execute the plan.
+        The end goal is to have Dockerfiles that are able to be built.*
 
         :::image type="content" source="media/containerization-prompt.png" alt-text="Screenshot that shows how to start the containerization process in GitHub Copilot using a prompt.":::
 
@@ -58,3 +64,7 @@ The GitHub Copilot app modernization for .NET containerization feature helps you
 
 - Use Claude Sonnet 4 or later models for the best results.
 - Copilot might take a few iterations to fix containerization errors.
+
+## Additional resources
+
+- We leverage certain tools in Containerization Assist. [Learn more](https://aka.ms/aks/containerization-assist)

docs/azure/migration/appmod/deploy.md

@@ -28,12 +28,18 @@ The App Modernization for .NET deployment feature helps you deploy your migrated
 
         :::image type="content" source="media/start-deploy.png" alt-text="Screenshot that shows how to start the deployment process in GitHub Copilot.":::
 
-    - **Use a deployment prompt**: You can enter the following prompt in Copilot chat to deploy your project to Azure:
+    - **Use a deployment prompt to provision new Azure infrastructure and deploy your project**: You can enter the following prompt in Copilot chat to deploy your project to Azure:
 
-        *Scan my project to identify all Azure-relevant resources, programming languages, frameworks, dependencies, and configuration files needed for deployment, and develop an architecture diagram for me using #appmod-generate-architecture-diagram. Based on that diagram, help me develop and execute a plan using #appmod-get-plan to deploy my project to Azure. deployTool: azcli, hosting service: non-aks.*
+        *Scan my project carefully to identify all Azure-relevant resources, programming languages, frameworks, dependencies, and configuration files needed for deployment. Develop an architecture diagram for me using #appmod-generate-architecture-diagram. Based on that diagram along with all info you get from project scan, help me develop a deploy-and-provision plan WITH TOOL #appmod-get-plan and execute it to deploy my project to Azure. deployTool: azd, IacType: Bicep, hosting service: non-aks.*
 
         :::image type="content" source="media/start-deploy-prompt.png" alt-text="Screenshot that shows how to start the deployment process in GitHub Copilot by using a prompt.":::
 
+    - **Use a deployment prompt to deploy your project to existing Azure resources**: You can enter the following prompt in Copilot chat to deploy your project to existing Azure resources:
+
+        *Deploy my project to my existing Azure resource group [resource group ID] in subscription [subscription ID]. Use the #appmod-get-plan tool to develop and execute a plan.*
+
+        :::image type="content" source="media/start-deploy-existing-prompt.png" alt-text="Screenshot that shows how to start the deploy to existing Azure resource process in GitHub Copilot by using a prompt.":::
+
 1. After you start the deployment, GitHub Copilot might ask for your approval to use tools or run commands. Grant permission when prompted.
 
 1. GitHub Copilot creates a plan. The plan explains the deployment strategy, including deployment goals, project information, Azure resource architecture, Azure resources, and execution steps.

docs/azure/migration/appmod/quickstart.md

@@ -107,5 +107,6 @@ You can choose one of the predefined options and send it in the chat:
 
 ## Next Steps
 
+- [Working with assessment](working-with-assessment.md)
 - [Predefined Tasks](predefined-tasks.md)
 - [Frequently Asked Questions](../../../core/porting/github-copilot-app-modernization/faq.yml)

docs/azure/migration/appmod/working-with-assessment.md

@@ -0,0 +1,135 @@
+---
+title: "Working with Assessment: Comprehensive guide to application assessment"
+description: Learn how to effectively work with application assessments in GitHub Copilot app modernization, including configuration, interpretation, and report management.
+author: KarlErickson
+ms.author: karler
+ms.reviewer: fenzho
+ms.topic: concept-article
+ms.date: 11/04/2025
+ms.custom: devx-track-dotnet
+ai-usage: ai-assisted
+---
+
+# Application assessment with GitHub Copilot app modernization
+
+This article shows you how to use assessment capabilities in GitHub Copilot app modernization to maximize the value of your application modernization process.
+
+## Overview
+
+Application assessment is a critical first step in your modernization journey. This article shows you how to configure assessments for different scenarios, work with assessment reports, and manage assessment data throughout your modernization process.
+
+## Configure before running assessment
+
+You can open the `.appmod/.appcat/assessment-config.json` file in your project to edit the configuration for application assessment to specify your target Azure service if it exists. For the first run of the assessment, the configuration file will be generated automatically.
+
+:::image type="content" source="media/configure-azure-service-target-for-assessment-report.png" lightbox="media/configure-azure-service-target-for-assessment-report.png" alt-text="Screenshot of Visual Studio that shows the GitHub Copilot app modernization assessment configuration.":::
+
+### Configuration properties
+
+You can edit this file to configure the application assessment. Any changes saved to this file will be applied the next time you run the assessment.
+
+The configurable arguments:
+
+**Target**: The Azure compute service to run the apps on. Select **Any** if you haven't decided which one to use and later you can choose and compare on the assessment report. By default, it's set as **Any**.
+
+| Target                            | Description                                                        |
+|-----------------------------------|--------------------------------------------------------------------|
+| Any                               | Discover issues for all supported targets here.                    |
+| AKS.Windows                       | Best practices for Azure Kubernetes Service (Windows).             |
+| AKS.Linux                         | Best practices for Azure Kubernetes Service (Linux).               |
+| AppService.Windows                | Best practices for Azure App Service (Windows).                    |
+| AppService.Linux                  | Best practices for Azure App Service (Linux).                      |
+| AppServiceContainer.Windows       | Best practices for Azure App Service Container (Windows).          |
+| AppServiceContainer.Linux         | Best practices for Azure App Service Container (Linux).            |
+| AppServiceManagedInstance.Windows | Best practices for Azure App Service Managed Instance (Windows).   |
+| ACA                               | Best practices for Azure Container Apps.                           |
+
+### Examples
+
+The following provide two examples of proper configurations:
+
+- Example one: You'd like to migrate your apps to Azure but haven't decided on the target compute service yet
+
+```json
+{
+  "appcat": {
+    "target": "Any"
+  }
+}
+```
+
+- Example two: You'd like to migrate your apps to App Service Linux and want to understand what issues need to be fixed.
+
+```json
+{
+  "appcat": {
+    "target": "AppService.Linux"
+  }
+}
+```
+
+After the assessment runs, the interactive dashboard opens automatically to provide comprehensive analysis results. When you configure the target Azure service as `Any`, you can switch between them to compare migration approaches and view service-specific recommendations. If you configure a specific target Azure service, you can only see one Azure service in the dropdown list.
+
+:::image type="content" source="./media/list-azure-service-target-for-assessment-report.png" lightbox="./media/list-azure-service-target-for-assessment-report.png" alt-text="Screenshot of Visual Studio showing the GitHub Copilot app modernization assessment dashboard with Azure service target selection options.":::
+
+## Interpreting assessment report
+
+The assessment reports provide comprehensive analysis results to help you understand your application's readiness for Azure migration and modernization. This section guides you through the report structure and helps you interpret the findings to make informed migration decisions.
+
+### Report structure overview
+
+The assessment report consists of several key sections:
+
+- **Application Information**: Basic information about your application including project numbers, frameworks, build tools, and target Azure service.
+- **Issue Summary**: Overview of migration issues categorized by domain with criticality percentages.
+- **Issues**: Provides a concise summary of all issues that require attention.
+
+:::image type="content" source="./media/assessment-report-dashboard.png" lightbox="./media/assessment-report-dashboard.png" alt-text="Screenshot of Visual Studio showing the GitHub Copilot app modernization assessment report dashboard.":::
+
+#### Issues
+
+The issues section provides a categorized list of various aspects of Cloud Readiness that you need to address to successfully migrate the application to Azure. The following tables describe the `Domain` and `Criticality` values:
+
+| Domain              | Description                                                                             |
+|---------------------|-----------------------------------------------------------------------------------------|
+| **Cloud Readiness** | Evaluates app dependencies to suggest Azure services and ensure cloud-native readiness. |
+
+| Criticality         | Description                                                   |
+|---------------------|---------------------------------------------------------------|
+| **Mandatory**       | Issues that must be fixed for migration to Azure.             |
+| **Potential**       | Issues that might impact migration and need review.           |
+| **Optional**        | Low-impact issues. Fixing them is recommended but optional.   |
+
+For more information, you can expand each reported issue by selecting the title. The report provides the following information:
+
+- A list of files where the incidents occurred, along with the number of code lines impacted. If the file is a .NET source file, then selecting the file line number directs you to the corresponding source report.
+- A detailed description of the issue. This description outlines the problem, provides any known solutions, and references supporting documentation regarding either the issue or resolution.
+
+:::image type="content" source="./media/assessment-report-issue-detail.png" lightbox="./media/assessment-report-issue-detail.png" alt-text="Screenshot of Visual Studio showing the GitHub Copilot app modernization assessment report issue details.":::
+
+## Operate assessment report
+
+Effective report management enables collaboration, maintains assessment history, and integrates with existing workflows.
+
+### Import assessment report
+
+Besides running the assessment directly in GitHub Copilot app modernization, you can also import assessment reports. The report can come from a .NET AppCAT CLI result, GitHub Copilot app modernization exported report, or app context file from Dr.Migrate.
+
+You can trigger importing a report by typing "import assessment report" in the chat when you enter the `Modernize` agent, or select the `Import` button in the assessment dashboard to import the report from the file explorer.
+
+:::image type="content" source="./media/import-assessment-report-in-chat.png" lightbox="./media/import-assessment-report-in-chat.png" alt-text="Screenshot of Visual Studio showing the GitHub Copilot app modernization assessment report import from chat.":::
+
+:::image type="content" source="./media/import-assessment-report.png" lightbox="./media/import-assessment-report.png" alt-text="Screenshot of Visual Studio showing the GitHub Copilot app modernization assessment report import interface.":::
+
+### Export assessment report
+
+In the assessment dashboard, you can view the issues detected by AppCAT and choose the migration solution. You can export the report and share it with others. This way, other people don't need to run the assessment themselves and can import the report to view the assessment and migration decisions directly.
+
+You can select the `Export` button in the assessment dashboard to export the report to the file explorer.
+
+:::image type="content" source="./media/export-assessment-report.png" lightbox="./media/export-assessment-report.png" alt-text="Screenshot of Visual Studio showing the GitHub Copilot app modernization assessment report export options and interface.":::
+
+## Next Steps
+
+- [Predefined Tasks](predefined-tasks.md)
+- [Frequently Asked Questions](../../../core/porting/github-copilot-app-modernization/faq.yml)

docs/azure/toc.yml

@@ -32,6 +32,8 @@ items:
           href: ../core/porting/github-copilot-app-modernization/faq.yml?toc=/dotnet/azure/toc.json&bc=/dotnet/breadcrumb/toc.json
         - name: Predefined Tasks
           href: ./migration/appmod/predefined-tasks.md
+        - name: Working with assessment
+          href: ./migration/appmod/working-with-assessment.md
         - name: Quickstart - Assess and migrate a .NET project
           href: ./migration/appmod/quickstart.md
         - name: Quickstart - Containerize a .NET project

docs/core/compatibility/10.0.md

@@ -147,6 +147,7 @@ If you're migrating an app to .NET 10, the breaking changes listed here might af
 
 | Title | Type of change    |
 |-------|-------------------|
+| [System.Text.Json checks for property name conflicts](serialization/10/property-name-validation.md) | Behavioral change |
 | [XmlSerializer no longer ignores properties marked with ObsoleteAttribute](serialization/10/xmlserializer-obsolete-properties.md) | Behavioral change |
 
 ## Windows Forms

docs/core/compatibility/serialization/10/property-name-validation.md

@@ -0,0 +1,68 @@
+---
+title: "Breaking change: System.Text.Json checks for property name conflicts"
+description: "Learn about the breaking change in .NET 10 where System.Text.Json validates that user-defined property names don't conflict with reserved metadata property names."
+ms.date: 11/13/2025
+ai-usage: ai-assisted
+---
+# System.Text.Json checks for property name conflicts
+
+Under certain contexts, such as polymorphism and reference preservation, <xref:System.Text.Json> reserves specific property names (for example, `$type`, `$id`, and `$ref`) for emitting metadata. Some property names such as the `TypeDiscriminatorPropertyName` can also be configured with custom names. Previously, the serializer didn't perform validation on whether these property names conflicted with user-defined contracts, which could result in duplicate properties and produce JSON that was ambiguous or failed to round-trip. Starting with .NET 10, System.Text.Json enables validation to prevent such configurations and provides early warning to users.
+
+## Version introduced
+
+.NET 10
+
+## Previous behavior
+
+Previously, the following code produced an invalid JSON object with duplicate `Type` properties and failed to deserialize with a <xref:System.Text.Json.JsonException>:
+
+```csharp
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+string json = JsonSerializer.Serialize<Animal>(new Dog());
+Console.WriteLine(json); // {"Type":"dog","Type":"Dog"}
+JsonSerializer.Deserialize<Animal>(json); // JsonException: Deserialized object contains a duplicate 'Type' metadata property.
+
+[JsonPolymorphic(TypeDiscriminatorPropertyName = "Type")]
+[JsonDerivedType(typeof(Dog), "dog")]
+public abstract class Animal
+{
+    public abstract string Type { get; }
+}
+
+public class Dog : Animal
+{
+    public override string Type => "Dog";
+}
+```
+
+## New behavior
+
+Starting in .NET 10, any attempt to serialize that same type results in an early validation error:
+
+> InvalidOperationException: The type 'Dog' contains property 'Type' that conflicts with an existing metadata property name. Consider either renaming it or ignoring it with JsonIgnoreAttribute.
+
+This validation error occurs when the serializer is first created or when serialization is first attempted, providing early detection of invalid serialization contracts.
+
+## Type of breaking change
+
+This change is a [behavioral change](../../categories.md#behavioral-change).
+
+## Reason for change
+
+This change provides early prevention of invalid serialization contracts. By validating property names upfront, the serializer prevents scenarios where duplicate properties would be emitted, resulting in invalid JSON that cannot round-trip correctly. This helps developers identify and fix configuration issues during development rather than discovering them at run time during deserialization.
+
+For more information, see:
+
+- [[STJ] Disallow property names that conflict with metadata property names (dotnet/runtime#106390)](https://github.com/dotnet/runtime/issues/106390)
+- [Disallow types with property names conflicting with metadata (dotnet/runtime#106460)](https://github.com/dotnet/runtime/pull/106460)
+
+## Recommended action
+
+Avoid using property names that conflict with System.Text.Json-specific metadata properties (such as `$type`, `$id`, and `$ref`). If it's absolutely necessary to keep such a property in the class, apply a <xref:System.Text.Json.Serialization.JsonIgnoreAttribute> annotation on the conflicting property.
+
+## Affected APIs
+
+- <xref:System.Text.Json.JsonSerializer.Deserialize*?displayProperty=fullName>
+- <xref:System.Text.Json.JsonSerializer.DeserializeAsync*?displayProperty=fullName>

docs/core/compatibility/toc.yml

@@ -174,6 +174,8 @@ items:
                 href: sdk/10.0/prune-packagereference-privateassets.md
           - name: Serialization
             items:
+              - name: System.Text.Json checks for property name conflicts
+                href: serialization/10/property-name-validation.md
               - name: XmlSerializer no longer ignores properties marked with ObsoleteAttribute
                 href: serialization/10/xmlserializer-obsolete-properties.md
           - name: Windows Forms