Merge pull request #6028 from MicrosoftDocs/master637395248824818592

For protected CLA branch, push strategy should use PR and merge to target branch method to work around git push error

Author: ghogen

docs/get-started/csharp/media/vs-2019/calculator-2-debug-call-stack.png

@@ -323,6 +323,110 @@ Real-world code involves many projects working together in a solution. Now, let'
    }
    ```
 
+## Debug: set and hit a breakpoint
+
+The Visual Studio debugger is a powerful tool that allows you to run your code step by step, to find the exact point where you made a programming mistake. You then understand what corrections you need to make in your code. Visual Studio allows you to make temporary changes so you can continue running the program.
+
+1. In *Program.cs*, click the margin to the left of the following code (or, open the shortcut menu and choose **Breakpoint** > **Insert Breakpoint**, or press **F9**):
+
+   ```csharp
+   result = calculator.DoOperation(cleanNum1, cleanNum2, op);
+   ```
+
+   The red circle that appears indicates a breakpoint. You can use breakpoints to pause your app and inspect code. You can set a breakpoint on any executable line of code.
+
+   ![Screenshot of setting a breakpoint](media/vs-2019/calculator-2-debug-set-breakpoint.png)
+
+1. Build and run the app.
+
+1. In the running app, type some values for the calculation:
+
+   - For the first number, type **8** and enter it.
+   - For the second number, type **0** and enter it.
+   - For the operator, let's have some fun; type **d** and enter it.
+
+   The app suspends where you created the breakpoint, which is indicated by the yellow pointer on the left and the highlighted code. The highlighted code has not yet executed.
+
+   ![Screenshot of hitting a breakpoint](media/vs-2019/calculator-2-debug-hit-breakpoint.png)
+
+   Now, with the app suspended you can inspect your application state.
+
+## Debug: view variables
+
+1. In the highlighted code, hover over variables such as `cleanNum1` and `op`. You see the current values for these variables (`8` and `d`, respectively), which appear in DataTips.
+
+   ![Screenshot of viewing a DataTip](media/vs-2019/calculator-2-debug-view-datatip.png)
+
+   When debugging, checking to see whether variables hold the values you expect them to hold is often critical to fixing issues.
+
+2. In the lower pane, look at the **Locals** window. (If it's closed, choose **Debug** > **Windows** > **Locals** to open it.)
+
+   In the Locals window, you see each variable that is currently in scope, along with its value and type.
+
+   ![Screenshot of Locals window](media/vs-2019/calculator-2-debug-locals-window.png)
+
+3. Look at the **Autos** window.
+
+   The Autos window is similar to the **Locals** window, but it shows the variables immediately preceding and following the current line of code where your app is paused.
+
+   Next, you will execute code in the debugger one statement at a time, which is called *stepping*.
+
+## Debug: step through code
+
+1. Press **F11** (or **Debug** > **Step Into**).
+
+   Using the Step Into command, the app executes the current statement and advances to the next executable statement (usually the next line of code). The yellow pointer on the left always indicates the current statement.
+
+   ![Screenshot of step into command](media/vs-2019/calculator-2-debug-step-into.png)
+
+   You've just stepped into the `DoOperation` method in the `Calculator` class.
+
+1. To get a hierarchical look at your program flow, look at the **Call Stack** window. (If it's closed, choose **Debug** > **Windows** > **Call Stack**.)
+
+   ![Screenshot of the call stack](media/vs-2019/calculator-2-debug-call-stack.png)
+
+   This view shows the current `Calculator.DoOperation` method, indicated by the yellow pointer, and the second row shows the function that called it, from the `Main` method in *Program.cs*. The **Call Stack** window shows the order in which methods and functions are getting called. In addition, it provides access to many debugger features, such as **Go to Source Code**, from the shortcut menu.
+
+1. Press **F10** (or **Debug** > **Step Over**) several times until the app pauses on the `switch` statement.
+
+   ```csharp
+   switch (op)
+   {
+   ```
+
+   The Step Over command is similar to the Step Into command, except that if the current statement calls a function, the debugger runs the code in the called function and doesn't suspend execution until the function returns. Step Over is a faster way to navigate code if you're not interested in a particular function.
+
+1. Press **F10** one more time so that the app pauses on the following line of code.
+
+   ```csharp
+   if (num2 != 0)
+   {
+   ```
+
+   This code checks for a divide-by-zero case. If the app continues, it will throw a general exception (an error), but let's say you consider this a bug, and want to do something else, like view the actual returned value in the console. One option is to use a debugger feature called Edit-and-continue to make changes to the code and then continue debugging. However, we will show you a different trick to temporarily modify the execution flow.
+
+## Debug: test a temporary change
+
+1. Select the yellow pointer, currently paused on the `if (num2 != 0)` statement, and drag it to the following statement.
+
+   ```csharp
+   result = num1 / num2;
+   ```
+
+   By doing this, the app completely skips the `if` statement, so you can see what happens when you divide by zero.
+
+1. Press **F10** to execute the line of code.
+
+1. Hover over the `result` variable and you see it stores a value of `Infinity`.
+
+   In C#, `Infinity` is the result when you divide by zero.
+
+1. Press **F5** (or, **Debug** > **Continue Debugging**).
+
+   The Infinity symbol shows up in the console as the result of the math operation.
+
+1. Close the app properly by using the 'n' command.
+
 ## Next steps
 
 Congratulations on completing this tutorial! To learn even more, continue with the following tutorials.

docs/get-started/csharp/media/vs-2019/calculator-2-debug-hit-breakpoint.png

@@ -15,9 +15,15 @@ To find memory leaks and inefficient memory usage, you can use tools such as the
 
 The Memory Usage tool lets you take one or more *snapshots* of the managed and native memory heap. You can collect snapshots of .NET, ASP.NET, C++, or mixed mode (.NET and native) apps. The **Memory Usage** tool can run on an open Visual Studio project, on an installed Microsoft Store app, or attached to a running app or process. You can run the **Memory Usage** tool with or without debugging. For more information, see [Run profiling tools with or without the debugger](../profiling/running-profiling-tools-with-or-without-the-debugger.md). In the debugger, you can turn memory profiling on and off, and see a per-object breakdown of memory usage. You can view memory usage results when execution is paused, for example at a breakpoint.
 
-.NET developers may choose between either the [Memory usage](../profiling/memory-usage.md) tool and the [.NET Object Allocation tool](../profiling/dotnet-alloc-tool.md).
-- The **.NET Object Allocation** tool helps you identify allocation patterns and anomalies in your .NET code, and helps identify common issues with garbage collection. This tool runs only as a post-mortem tool. You can run this tool on local or remote machines.
-- The **Memory usage** tool is helpful in identifying memory leaks, which are not typically common in .NET apps. If you need to use debugger features while checking memory, such as stepping through code, the [debugger-integrated Memory usage](../profiling/beginners-guide-to-performance-profiling.md) tool is recommended.
+.NET developers may choose between either the .NET Object Allocation tool or the [Memory usage](../profiling/memory-usage.md) tool.
+
+- The [.NET Object Allocation tool](../profiling/dotnet-alloc-tool.md) helps you identify allocation patterns and anomalies in your .NET code, and helps identify common issues with garbage collection. This tool runs only as a post-mortem tool. You can run this tool on local or remote machines.
+- The [Memory Usage tool](../profiling/memory-usage-without-debugging2.md) is helpful in identifying memory leaks, which are not typically common in .NET apps. If you need to use debugger features while checking memory, such as stepping through code, the [debugger-integrated Memory usage](../profiling/memory-usage.md) tool is recommended.
+
+C++ developers can use either the debugger-integrated or non-debugger Memory Usage tool.
+
+- [Analyze memory usage with the debugger](../profiling/memory-usage.md)
+- [Analyze memory usage without the debugger](../profiling/memory-usage-without-debugging2.md)
 
 You can use the profiling tools without the debugger with Windows 7 and later. Windows 8 and later is required to run profiling tools with the debugger (**Diagnostic Tools** window).
 
@@ -29,6 +35,5 @@ You can use the profiling tools without the debugger with Windows 7 and later. W
 
 ## See also
 
-- [Analyze memory usage without the debugger](../profiling/memory-usage-without-debugging2.md)
 - [Profiling in Visual Studio](../profiling/index.yml)
 - [First look at profiling tools](../profiling/profiling-feature-tour.md)

docs/get-started/csharp/media/vs-2019/calculator-2-debug-locals-window.png

@@ -18,7 +18,7 @@ ms.workload:
 
 The **Memory Usage** tool monitors your app's memory use. You can use the tool to study the real-time memory effects of scenarios you're actively developing in Visual Studio. You can take detailed snapshots of the app's memory states, and compare snapshots to find the root causes of memory issues. The Memory Usage tool is supported on .NET, ASP.NET, C++, or mixed mode (.NET and native) apps.
 
-The Memory Usage tool can run [with or without the debugger](../profiling/running-profiling-tools-with-or-without-the-debugger.md). In this article, we show how to use the Memory Usage tool without the debugger in the Visual Studio **Performance Profiler**.
+The Memory Usage tool can run [with or without the debugger](../profiling/running-profiling-tools-with-or-without-the-debugger.md). In this article, we show how to use the Memory Usage tool without the debugger in the Visual Studio **Performance Profiler**, which is recommended for release builds.
 
 ## Memory Usage diagnostic sessions
 

docs/get-started/csharp/media/vs-2019/calculator-2-debug-set-breakpoint.png

@@ -56,8 +56,8 @@ For more information on using the CPU Usage or Memory usage tool in the Performa
 Tools available in the Performance Profiler include:
 
 - [CPU usage](../profiling/cpu-usage.md)
-- [Memory usage for .NET code](../profiling/dotnet-alloc-tool.md)
-- [Memory usage](#analyze-memory-usage)
+- [.NET object allocation](../profiling/dotnet-alloc-tool.md)
+- [Memory usage](../profiling/memory-usage-without-debugging2.md)
 - [.NET async tool](../profiling/analyze-async.md)
 - [Database tool](../profiling/analyze-database.md)
 - [GPU usage](../profiling/gpu-usage.md)
@@ -101,7 +101,12 @@ Double-click on a function that you are interested in, and you will see a more d
 
 ## Analyze memory usage
 
-The **Diagnostic Tools** window also allows you to evaluate memory usage in your app using the **Memory Usage** tool. For example, you can look at the number and size of objects on the heap. You can use the [debugger-integrated Memory Usage tool](../profiling/memory-usage.md) or the [post-mortem Memory Usage tool](../profiling/memory-usage-without-debugging2.md) in the Performance Profiler. Another memory analysis tool, the [.NET Object Allocation tool](../profiling/dotnet-alloc-tool.md), helps you identify allocation patterns and anomalies in your .NET code.
+The **Diagnostic Tools** window also allows you to evaluate memory usage in your app using the **Memory Usage** tool. For example, you can look at the number and size of objects on the heap. You can use the [debugger-integrated Memory Usage tool](../profiling/memory-usage.md) or the [post-mortem Memory Usage tool](../profiling/memory-usage-without-debugging2.md) in the Performance Profiler.
+
+.NET developers may choose between either the [.NET Object Allocation tool](../profiling/dotnet-alloc-tool.md) or the [Memory usage](../profiling/memory-usage.md) tool.
+
+- The **.NET Object Allocation** tool helps you identify allocation patterns and anomalies in your .NET code, and helps identify common issues with garbage collection. This tool runs only as a post-mortem tool. You can run this tool on local or remote machines.
+- The **Memory usage** tool is helpful in identifying memory leaks, which are not typically common in .NET apps. If you need to use debugger features while checking memory, such as stepping through code, the [debugger-integrated Memory usage](../profiling/beginners-guide-to-performance-profiling.md) tool is recommended.
 
 To analyze memory usage with the **Memory Usage** tool, you need to take at least one memory snapshot. Often, the best way to analyze memory is to take two snapshots; the first right before a suspected memory issue, and the second snapshot right after a suspected memory issue occurs. Then you can view a diff of the two snapshots and see exactly what changed. The following illustration shows taking a snapshot with the debugger-integrated tool.
 
@@ -163,7 +168,7 @@ In your UWP apps, you can enable **UI Analysis** in the **Diagnostic Tools** win
 
 In Direct3D apps (Direct3D components must be in C++), you can examine activity on the GPU and analyze performance issues. For more information, see [GPU Usage](./gpu-usage.md). To use the tool, choose **GPU Usage** in the Performance Profiler, and then choose **Start**. In your app, go through the scenario that you're interested in profiling, and then choose **Stop collection** to generate a report.
 
-When you select a time period in the graphs and choose **view details**, a detailed view appears in the lower pane. In the detailed view, you can examine how much activity is happening on each CPU and GPU. Select events in the lowest pane to get popups in the timeline. For example, select the **Present** event to view **Present** call popups. (The light gray vertical Vsync lines can be used as a reference to understand whether certain **Present** calls missed Vsync. There must be one **Present** call between every two Vsyncs in order for the app to steadily hit 60 FPS.)
+When you select a time period in the graphs and choose **view details**, a detailed view appears in the lower pane. In the detailed view, you can examine how much activity is happening on each CPU and GPU. Select events in the lowest pane to get popups in the timeline. For example, select the **Present** event to view **Present** call popups. (The light gray vertical VSync lines can be used as a reference to understand whether certain **Present** calls missed VSync. There must be one **Present** call between every two VSyncs in order for the app to steadily hit 60 FPS.)
 
 ![GPU Usage profiling tool](../profiling/media/prof-tour-gpu-usage.png "Diag GPU Usage")
 

docs/get-started/csharp/media/vs-2019/calculator-2-debug-step-into.png

@@ -25,6 +25,7 @@ To help decide which tools and results to use, consider the following:
   - External performance problems, like file I/O or network responsiveness issues, won't look much different in the debugger or non-debugger tools.
   - The debugger itself changes performance times, as it does necessary debugger operations like intercepting exception and module load events.
   - Release build performance numbers in the Performance Profiler are the most precise and accurate. Debugger-integrated tool results are most useful to compare with other debugging-related measurements, or to use debugger features.
+  - Some tools, such as the .NET Object Allocation tool, are only available for non-debugger scenarios.
 - Debug vs. release build
   - For problems caused by CPU-intensive calls, there might be considerable performance differences between release and debug builds. Check to see whether the issue exists in release builds.
   - If the problem occurs only during debug builds, you probably don't need to run the non-debugger tools. For release build problems, decide whether features provided by the debugger-integrated tools will help to pinpoint the problem.

docs/get-started/csharp/media/vs-2019/calculator-2-debug-view-datatip.png

@@ -1,10 +1,10 @@
 ---
-title: Technical Support Benefit
+title: Technical Support benefit in Visual Studio subscriptions
 author: evanwindom
 ms.author: v-evwin
 manager: cabuschl
 ms.assetid: 2e0fd8bb-8f20-487c-b350-b8fde405ea5e
-ms.date: 09/02/2020
+ms.date: 10/28/2020
 ms.topic: how-to
 description: Learn how to activate the technical support benefit included with your Visual Studio subscription.
 ---

docs/get-started/csharp/tutorial-console-part-2.md

@@ -2,9 +2,9 @@
 title: How to purchase Visual Studio cloud subscriptions
 author: evanwindom
 ms.author: v-evwin
-manager: lank
+manager: cabuschl
 ms.assetid: af1f7888-6942-4515-9475-0928ecf49dab
-ms.date: 10/21/2020
+ms.date: 10/28/2020
 ms.topic: overview
 description:  Rent Visual Studio Professional or Visual Studio Enterprise on a month-to-month or annual basis, with no long-term contract.
 ---
@@ -100,7 +100,7 @@ A:  No.  Your subscriptions will remain in place and you will be able to manage
 A: Annual subscriptions that are purchased during a given month are charged immediately for a full year and are valid for a full year. For that reason, you can modify the number of licenses only in the current month of purchase (they will be valid for one year and charged for one year). Outside of the month of purchase, it is no longer possible to increase the number of subscriptions.
 
 #### Q: What if I want to decrease the number of subscriptions for my customers?
-A: Your administrator can still decrease the number of subscriptions by visiting https://manage.visualstudio.com and following the instructions in this article to decrease subscription counts. The system will *not* generate a pro-rated credit. For a refund you will need to contact the Azure billing team.
+A: Your admin can still decrease the number of subscriptions by visiting https://manage.visualstudio.com and following the instructions in this article to decrease subscription counts. The system will *not* generate a pro-rated credit. For a refund you will need to contact the Azure billing team.
 
 #### Q: If I cancel my subscription, will I be able to buy another Annual Cloud subscription later?
 A:  Although you will not be able to buy another Cloud Annual subscription, there are many options to purchase Visual Studio Subscriptions.  Learn more at [https://visualstudio.microsoft.com/vs/pricing/](https://visualstudio.microsoft.com/vs/pricing/).
@@ -113,10 +113,10 @@ A:  Your customers will not be able to purchase new Visual Studio Cloud Annual s
 A:  Existing customers will not be impacted. New customers will need to decide whether they want to purchase Visual Studio Monthly subscriptions or go to another channel such as volume licensing to purchase Visual Studio Subscriptions.
 
 #### Q: What if I want to increase the number of subscriptions for my customers?
-A: Annual subscriptions purchased during a given month are charged immediately for a full year and are valid for a full year. For that reason, your administrator can only modify the number of licenses in the current month of purchase (they will be valid for 1 year and charged for 1 year). Outside of the month of purchase it is no longer possible to increase the number of subscriptions.
+A: Annual subscriptions purchased during a given month are charged immediately for a full year and are valid for a full year. For that reason, your admin can only modify the number of licenses in the current month of purchase (they will be valid for 1 year and charged for 1 year). Outside of the month of purchase it is no longer possible to increase the number of subscriptions.
 
 #### Q: What if I want to decrease the number of subscriptions for my customers?
-A:  Your administrator can still decrease the number of subscriptions by visiting [https://manage.visualstudio.com](https://manage.visualstudio.com) and following the instructions in this article to decrease subscription counts. The system will **not** generate a pro-rated credit. For a refund you will need to contact the Azure billing team.
+A:  Your admin can still decrease the number of subscriptions by visiting [https://manage.visualstudio.com](https://manage.visualstudio.com) and following the instructions in this article to decrease subscription counts. The system will **not** generate a pro-rated credit. For a refund you will need to contact the Azure billing team.
 
 #### Q: If my customers cancel their subscriptions, will they be able to buy more Annual Cloud subscriptions later?
 A:  Although they will not be able to buy another Cloud Annual subscription, there are many options to purchase Visual Studio Subscriptions.  Learn more at [https://visualstudio.microsoft.com/vs/pricing/](https://visualstudio.microsoft.com/vs/pricing/).