Merge pull request #14077 from MicrosoftDocs/main

Merged by Learn.Build PR Management system

Author: learn-build-service-prod[bot]

docs/ide/reference/options-text-editor-csharp-advanced.md

@@ -149,7 +149,7 @@ Select these check boxes to display dotted vertical lines between the curly brac
 
 - Don't put ref or out on custom struct
 
-   Uncheck this checkbox to avoid potentially unintended cloning of structs by refencing existing struct objects when extracting an expression into a method call.
+   Uncheck this checkbox to avoid potentially unintended cloning of structs by referencing existing struct objects when extracting an expression into a method call.
 
    ### Example
 

docs/profiling/isolate-performance-issue.md

@@ -1,7 +1,7 @@
 ---
 title: "Isolate a performance issue"
 description: "Learn how to use .NET Counters and the Instrumentation tools to identify, isolate, and resolve performance issues."
-ms.date: 3/26/2025
+ms.date: 7/3/2025
 ms.topic: conceptual
 dev_langs:
   - "CSharp"
@@ -18,52 +18,49 @@ monikerRange: '>= vs-2022'
 
 # Case study: Isolate a performance issue (C#, Visual Basic, F#)
 
-Use the profiling tools to investigate performance issues and isolate problem areas. This case study uses a sample application with performance issues to demonstrate how to use profiling tools to improve efficiency. If you want to compare profiling tools, see [Which tool should I choose?](../profiling/choose-performance-tool.md)
+This case study demonstrates how to use Visual Studio profiling tools to identify and resolve performance issues in a sample ASP.NET application. For a comparison of profiling tools, see [Which tool should I choose?](../profiling/choose-performance-tool.md)
 
-This case study covers these topics:
+You'll learn:
 
 - How to use Visual Studio profiling tools to analyze application performance.
-- How to interpret the data provided by these tools to identify performance bottlenecks.
-- How to apply practical strategies to optimize code, focusing on .NET Counters, call counts, and timing data.
+- How to interpret profiling data to find bottlenecks.
+- Practical strategies for optimizing code using .NET Counters, call counts, and timing data.
 
-Follow along and then apply these techniques to your own applications to make them more efficient and cost-effective.
+Apply these techniques to improve your own applications.
 
 ## Isolate a performance issue case study
 
-The sample application in this case study is an ASP.NET app that runs queries against a simulated database. The example is based on the [Diagnostics Sample](/dotnet/core/diagnostics/debug-threadpool-starvation).
+The sample ASP.NET app runs queries against a simulated database and is based on the [Diagnostics Sample](/dotnet/core/diagnostics/debug-threadpool-starvation).
 
-The primary performance issue with the sample application lies in inefficient coding patterns. The application has a performance bottleneck that significantly impacts its efficiency. The problem includes the following symptoms:
+Key performance symptoms:
 
-- **Low CPU Usage**: The application shows low CPU usage, indicating that the CPU is not the bottleneck.
+- **Low CPU Usage**: The CPU is not the bottleneck.
+- **High ThreadPool Thread Count**: Thread count rises steadily, indicating thread pool starvation.
+- **Slow Application Response**: The app responds slowly due to a lack of available threads.
 
-- **High ThreadPool Thread Count**: The thread count is relatively high and steadily rising, suggesting thread pool starvation.
-
-- **Slow Application Response**: The application responds slowly due to the lack of available threads to process new work items.
-
-The case study aims to address these issues by employing Visual Studio's profiling tools to analyze the application's performance. By understanding where and how the application's performance can be improved, developers can implement optimizations to make code faster and more efficient. The ultimate goal is to enhance the application's overall performance, making it more efficient and cost-effective to run.
+This case study uses Visual Studio profiling tools to pinpoint and address these issues, helping you make your code faster and more efficient.
 
 ## Challenge
 
-Addressing the performance issues in the sample .NET application presents several challenges. These challenges stem from the complexity of diagnosing performance bottlenecks. The key challenges in fixing the problems described are as follows:
-
-- **Diagnosing Performance Bottlenecks**: One of the primary challenges is accurately identifying the root causes of the performance issues. Low CPU usage combined with slow performance can have multiple contributing factors. Developers must use profiling tools effectively to diagnose these issues, which requires some understanding of how these tools work and how to interpret their output.
+Fixing these issues involves several challenges:
 
-- **Knowledge and Resource Constraints**: Teams may face constraints related to knowledge, expertise, and resources. Profiling and optimizing an application requires specific skills and experience, and not all teams may have immediate access to these resources.
+- **Diagnosing Bottlenecks**: Low CPU usage with slow performance can have multiple causes. Effective use of profiling tools and interpreting their output is essential.
+- **Knowledge and Resource Constraints**: Profiling and optimization require specific skills and experience, which may not always be available.
 
-Addressing these challenges requires a strategic approach that combines effective use of profiling tools, technical knowledge, and careful planning and testing. The case study aims to guide developers through this process, providing strategies and insights to overcome these challenges and improve the application's performance.
+A strategic approach combining profiling tools, technical knowledge, and careful testing is key to overcoming these challenges.
 
 ## Strategy
 
 Here is a high-level view of the approach in this case study:
 
-- We start the investigation by watching .NET counter metrics while collecting performance data. Like the CPU Usage tool, Visual Studio's [.NET Counters](../profiling/dotnet-counters-tool.md) tool is also a good starting point for a performance investigation.
-- Next, for additional insights to help isolate issues or improve the performance, consider collecting a trace using one of the other profiling tools. For example, take a look at call counts and timing data using the [Instrumentation](../profiling/instrumentation.md) tool.
+- Start by monitoring .NET counter metrics while collecting performance data. Visual Studio's [.NET Counters](../profiling/dotnet-counters-tool.md) tool is a good starting point.
+- For deeper insights, collect traces with additional profiling tools, such as the [Instrumentation](../profiling/instrumentation.md) tool for call counts and timing data.
 
 Data collection requires the following tasks:
 
-- Setting the app to a Release build.
-- Select the .NET Counters tool from the Performance Profiler (**Alt+F2**). (Later steps involve the Instrumentation tool.)
-- From the Performance Profiler, start the app and collect a trace.
+- Set the app to Release build.
+- Select the .NET Counters tool in Performance Profiler (**Alt+F2**).
+- Start the app and collect a trace.
 
 ## Check performance counters
 

docs/profiling/optimize-code-using-profiling-tools.md

@@ -1,7 +1,7 @@
 ---
 title: "Beginner's guide to optimizing code"
 description: "Learn how to optimize code and reduce compute costs using Visual Studio profiling tools such as the CPU Usage tool, the .NET Object Allocation tool, and the Database tool."
-ms.date: 3/26/2025
+ms.date: 7/3/2025
 ms.topic: conceptual
 ms.custom: "profiling-seo"
 dev_langs:
@@ -18,55 +18,50 @@ monikerRange: '>= vs-2022'
 ---
 # Case Study: Beginner's guide to optimizing code and reducing compute costs (C#, Visual Basic, C++, F#)
 
-Reducing your compute time means reducing costs, so optimizing your code can save money. This case study uses a sample application with performance issues to demonstrate how to use profiling tools to improve efficiency. If you want to compare profiling tools, see [Which tool should I choose?](../profiling/choose-performance-tool.md)
+Optimizing your code reduces compute time and costs. This case study demonstrates how to use Visual Studio profiling tools to identify and fix performance issues in a sample .NET application. If you want to compare profiling tools, see [Which tool should I choose?](../profiling/choose-performance-tool.md)
 
-This case study covers these topics:
+This guide covers:
 
-- The importance of code optimization and its impact on reducing compute costs.
-- How to use Visual Studio profiling tools to analyze application performance.
-- How to interpret the data provided by these tools to identify performance bottlenecks.
-- How to apply practical strategies to optimize code, focusing on CPU usage, memory allocation, and database interactions.
+- How to use Visual Studio profiling tools to analyze and improve performance.
+- Practical strategies for optimizing CPU usage, memory allocation, and database interactions.
 
-Follow along and then apply these techniques to your own applications to make them more efficient and cost-effective.
+Apply these techniques to make your own applications more efficient.
 
 ## Optimization case study
 
-The sample application examined in this case study is a .NET application that runs queries against a database of blogs and blog posts. It utilizes the Entity Framework, a popular ORM (Object-Relational Mapping) for .NET, to interact with a SQLite local database. The application is structured to execute a large number of queries, simulating a real-world scenario where a .NET application might be required to handle extensive data retrieval tasks. The sample application is a modified version of the [Entity Framework getting started sample](/ef/core/get-started/overview/first-app).
+The sample .NET application runs queries against a SQLite database of blogs and posts using Entity Framework. It executes many queries, simulating a real-world data retrieval scenario. The app is based on the [Entity Framework getting started sample](/ef/core/get-started/overview/first-app), but uses a larger dataset.
 
-The primary performance issue with the sample application lies in how it manages compute resources and interacts with the database. The application has a performance bottleneck that significantly impacts its efficiency and, consequently, the compute costs associated with running it. The problem includes the following symptoms:
+Key performance issues include:
 
-- **High CPU Usage**: Applications may perform inefficient computations or processing tasks in a way that unnecessarily consumes a large amount of CPU resources. This can lead to slow response times and increased operational costs.
+- **High CPU Usage**: Inefficient computations or processing tasks increase CPU consumption and costs.
+- **Inefficient Memory Allocation**: Poor memory management leads to excessive garbage collection and reduced performance.
+- **Database Overheads**: Inefficient queries and excessive database calls degrade performance.
 
-- **Inefficient Memory Allocation**: Applications can sometimes face issues related to memory usage and allocation. In .NET apps, inefficient memory management can lead to increased garbage collection, which in turn can affect application performance.
-
-- **Database Interaction Overheads**: Applications that execute a large number of queries against a database can experience bottlenecks related to database interactions. This includes inefficient queries, excessive database calls, and poor use of Entity Framework capabilities, all of which can degrade performance.
-
-The case study aims to address these issues by employing Visual Studio's profiling tools to analyze the application's performance. By understanding where and how the application's performance can be improved, developers can implement optimizations to reduce CPU usage, improve memory allocation efficiency, streamline database interactions, and optimize resource utilization. The ultimate goal is to enhance the application's overall performance, making it more efficient and cost-effective to run.
+This case study uses Visual Studio profiling tools to pinpoint and address these issues, aiming to make the application more efficient and cost-effective.
 
 ## Challenge
 
-Addressing the performance issues in the sample .NET application presents several challenges. These challenges stem from the complexity of diagnosing performance bottlenecks. The key challenges in fixing the problems described are as follows:
-
-- **Diagnosing Performance Bottlenecks**: One of the primary challenges is accurately identifying the root causes of the performance issues. High CPU usage, inefficient memory allocation, and database interaction overheads can have multiple contributing factors. Developers must use profiling tools effectively to diagnose these issues, which requires some understanding of how these tools work and how to interpret their output.
+Fixing these performance issues involves several challenges:
 
-- **Knowledge and Resource Constraints**: Finally, teams may face constraints related to knowledge, expertise, and resources. Profiling and optimizing an application requires specific skills and experience, and not all teams may have immediate access to these resources.
+- **Diagnosing Bottlenecks**: Identifying root causes of high CPU, memory, or database overheads requires effective use of profiling tools and a correct interpretion of results.
+- **Knowledge and Resource Constraints**: Profiling and optimization require specific skills and experience, which may not always be available.
 
-Addressing these challenges requires a strategic approach that combines effective use of profiling tools, technical knowledge, and careful planning and testing. The case study aims to guide developers through this process, providing strategies and insights to overcome these challenges and improve the application's performance.
+A strategic approach combining profiling tools, technical knowledge, and careful testing is essential to overcome these challenges.
 
 ## Strategy
 
 Here is a high-level view of the approach in this case study:
 
-- We start the investigation by taking a CPU usage trace. Visual Studio's [CPU Usage tool](../profiling/cpu-usage.md) is often helpful to begin performance investigations and to optimize code to reduce cost.
-- Next, to get additional insights to help isolate issues or improve the performance, we collect a trace using one of the other profiling tools. For example:
-  - We take a look at the memory usage. For .NET, we try the [.NET Object Allocation tool](../profiling/dotnet-alloc-tool.md) first. (For either .NET or C++, you can look at the Memory Usage tool instead.)
-  - For ADO.NET or Entity Framework, we can use the [Database tool](../profiling/analyze-database.md) to examine SQL queries, precise query time, and more.
+- Start with a CPU usage trace using Visual Studio's [CPU Usage tool](../profiling/cpu-usage.md). Visual Studio's CPU Usage tool is a good starting point for performance investigations.
+- Collect additional traces for memory and database analysis:
+  - Use the [.NET Object Allocation tool](../profiling/dotnet-alloc-tool.md) for memory insights.
+  - Use the [Database tool](../profiling/analyze-database.md) to examine SQL queries and timings.
 
 Data collection requires the following tasks:
 
-- Setting the app to a Release build.
-- Selecting the CPU Usage tool from the Performance Profiler (**Alt+F2**). (Later steps involve a few of the other tools.)
-- From the Performance Profiler, start the app and collect a trace.
+- Set the app to Release build.
+- Select the CPU Usage tool in Performance Profiler (**Alt+F2**).
+- In the Performance Profiler, start the app and collect a trace.
 
 ### Inspect areas of high CPU usage
 

docs/snippets/cpp/VS_Snippets_Misc/wrl-media-capture/cpp/grayscaletransform/grayscaletransform.cpp

@@ -352,7 +352,7 @@ void TransformChroma(const D2D1::Matrix3x2F& mat, BYTE *pu, BYTE *pv)
 //
 // The image conversion functions take the following parameters:
 //
-// mat               Transfomation matrix for chroma values.
+// mat               Transformation matrix for chroma values.
 // rcDest            Destination rectangle.
 // pDest             Pointer to the destination buffer.
 // lDestStride       Stride of the destination buffer, in bytes.

docs/snippets/cpp/VS_Snippets_Winforms/Classic Application.ThreadException Example/CPP/source.cpp

@@ -75,7 +75,7 @@ public ref class Form1: public System::Windows::Forms::Form
    private:
       System::Windows::Forms::DialogResult ShowThreadExceptionDialog( Exception^ e )
       {
-         String^ errorMsg = "An error occurred please contact the adminstrator with the following information:\n\n";
+         String^ errorMsg = "An error occurred please contact the administrator with the following information:\n\n";
          errorMsg = String::Concat( errorMsg, e->Message, "\n\nStack Trace:\n", e->StackTrace );
          return MessageBox::Show( errorMsg, "Application Error", MessageBoxButtons::AbortRetryIgnore, MessageBoxIcon::Stop );
       }

docs/snippets/cpp/VS_Snippets_Winforms/ComboBox/CPP/comboboxcomplex.cpp

@@ -73,7 +73,7 @@ public ref class Win32Form1: public System::Windows::Forms::Form
       this->label2->Location = System::Drawing::Point( 0, 40 );
       this->label2->Size = System::Drawing::Size( 48, 24 );
       this->label2->TabIndex = 7;
-      this->label2->Text = "Sring 1";
+      this->label2->Text = "String 1";
       this->label2->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
       this->label3->Location = System::Drawing::Point( 0, 72 );
       this->label3->Size = System::Drawing::Size( 48, 23 );

docs/snippets/cpp/VS_Snippets_Winforms/Control_StyleChanged/CPP/control_stylechanged.cpp

@@ -86,7 +86,7 @@ public ref class MyForm: public Form
    // Handle the 'StyleChanged' event for the 'Form'.
    void MyForm_StyleChanged( Object^ /*sender*/, EventArgs^ /*e*/ )
    {
-      MessageBox::Show( "The style releated to the 'Form' has been changed" );
+      MessageBox::Show( "The style related to the 'Form' has been changed" );
    }
    // </Snippet1>
 };

docs/snippets/cpp/VS_Snippets_Winforms/DataGridTableStyle_Header_4/CPP/datagridtablestyle_header_4.cpp

@@ -4,7 +4,7 @@
 /*
 The following program demonstrates the usage of properties 'HeaderBackColor',
 'HeaderForeColor' and events 'HeaderBackColorChanged', 'HeaderForeColorChanged'.
-A table is created and added to a datagrid with two coloumns.The table allows to change
+A table is created and added to a datagrid with two columns.The table allows to change
 Header's  background and foreground colors through selection of combobox values.
 */
 

docs/snippets/cpp/VS_Snippets_Winforms/DataGridTableStyle_ResetBackColor/CPP/datagridtablestyle_resetbackcolor.cpp

@@ -43,7 +43,7 @@ public ref class MyForm: public Form
 
 private:
 
-   // Initialilze form and its controls.
+   // Initialize form and its controls.
    void InitializeComponent()
    {
       myDataGrid = gcnew DataGrid;

docs/snippets/cpp/VS_Snippets_Winforms/IDesignerExample/CPP/testcontrol.cpp

@@ -41,7 +41,7 @@ public ref class ExampleIDesigner: public System::ComponentModel::Design::IDesig
       this->component = component;
    }
 
-   // This method peforms the 'default' action for the designer. The default action 
+   // This method performs the 'default' action for the designer. The default action 
    // for a basic IDesigner implementation is invoked when the designer's component 
    // is double-clicked. By default, a component associated with a basic IDesigner 
    // implementation is displayed in the design-mode component tray.