Merge pull request #904 from MicrosoftDocs/master

merge to live

Author: ghogen

.openpublishing.publish.config.json

@@ -92,6 +92,11 @@
       "branch": "master",
       "branch_mapping": {}
     },
+    {
+      "path_to_root": "_themes.pdf",
+      "url": "https://github.com/Microsoft/templates.docs.msft.pdf",
+      "branch": "master"
+    },
     {
       "path_to_root": "_repo.en-us",
       "url": "https://github.com/MicrosoftDocs/visualstudio-docs-pr",
@@ -111,6 +116,11 @@
       }
     }
   ],
+  "Targets": {
+    "Pdf": {
+      "template_folder": "_themes.pdf"
+    }
+  },
   "branch_target_mapping": {
     "live": [
       "Publish",
@@ -120,4 +130,4 @@
   "need_generate_pdf_url_template": true,
   "need_generate_pdf": false,
   "need_generate_intellisense": false
-}
+}

docs/debugger/debugger-tips-and-tricks.md

@@ -79,7 +79,7 @@ It's easy to view variables using debugger windows like the **Watch** window. Ho
 
 5.  Right-click the object ID variable and choose **Add Watch**.
 
-For more information, see [Create an Object ID](https://docs.microsoft.com/en-us/visualstudio/debugger/watch-and-quickwatch-windows.md#bkmk_objectIds).
+For more information, see [Create an Object ID](../debugger/watch-and-quickwatch-windows.md#bkmk_objectIds).
 
 ## View return values for functions
 
@@ -157,7 +157,10 @@ To find out how the debugger classifies code as user code, see [Just My Code](..
 
 ## Learn more
 
-See this visual studio [blog post](https://blogs.msdn.microsoft.com/visualstudio/2017/06/26/7-lesser-known-hacks-for-debugging-in-visual-studio/) that describes some lesser known tips and tricks.
+For additional tips and tricks and more detailed information, see these blog posts:
+
+- [7 lesser known hacks for debugging in Visual Studio](https://blogs.msdn.microsoft.com/visualstudio/2017/06/26/7-lesser-known-hacks-for-debugging-in-visual-studio/)
+- [7 hidden gems in Visual Studio](https://blogs.msdn.microsoft.com/visualstudio/2017/10/05/7-hidden-gems-in-visual-studio-2017/)
 
 ## See Also
 [Keyboard Shortcuts](../ide/tips-and-tricks-for-visual-studio.md)

docs/debugger/includes/remote-debugger-download.md

@@ -32,6 +32,6 @@ translation.priority.ht:
     >   
     >  Surface 3 switched from ARM to x64 architecture. An ARM version of the remote tools is not available for Visual Studio 2017. For Visual Studio 2015, find the ARM version in the Visual Studio 2015 RTW download.
   
-3.  When you have finished downloading the executable, follow the directions to install the application on the remote computer. Follow the [setup instructions](#bkmk_setup).
+3.  When you have finished downloading the executable, go to the next section and follow setup instructions.
 
 If you try to copy the remote debugger (msvsmon.exe) to the remote computer and run it, be aware that the **Remote Debugger Configuration Wizard** (**rdbgwiz.exe**) is installed only when you download the tools. You may need to use the wizard for configuration later, especially if you want the remote debugger to run as a service. For more information, see [(Optional) Configure the remote debugger as a service](../../debugger/remote-debugging.md#bkmk_configureService).

docs/debugger/using-the-debuggerdisplay-attribute.md

@@ -8,11 +8,6 @@ ms.technology:
   - "vs-ide-debug"
 ms.tgt_pltfrm: ""
 ms.topic: "article"
-dev_langs: 
-  - "CSharp"
-  - "VB"
-  - "FSharp"
-  - "C++"
 helpviewer_keywords: 
   - "attributes [C#], debugger"
   - "DebuggerDisplay attribute"

docs/debugger/watch-and-quickwatch-windows.md

@@ -44,15 +44,15 @@ static void Main(string[] args)
 }  
 ```  
 
- You can observe the a variable in the QuickWatch window as follows:  
+ You can observe a variable in the QuickWatch window as follows:  
 
 1.  Set a breakpoint on the `a = a + b;` line.  
 
 2.  Start debugging. Execution stops at the breakpoint.  
 
 3.  Open the **QuickWatch** window (right-click on a, then choose **QuickWatch**, or **SHIFT+F9**).
 
-    You should see the a variable in the **Values** window, with a value of 1.
+    You should see a variable in the **Values** window, with a value of 1.
 
     ![QuickWatch Expression](../debugger/media/watchexpression.png "QuickWatchExpression")  
 
@@ -104,7 +104,7 @@ int main()
 
  You should see the variable values changing as you iterate through the `for` loop.  
 
- If you are programming in native code, you may sometimes need to qualify the context of a variable name or an expression containing a variable name. The context is the function, source file, and module where a variable is located. If you have to do this, you can use the context operator syntax. For more information, see [Context Operator (C++)](../debugger/context-operator-cpp.md).  
+ If you are programming in native code, you may sometimes need to qualify the context of a variable name or an expression containing a variable name. The context is the function, source file, and module where a variable is located. If you have to qualify the context, you can use the context operator syntax. For more information, see [Context Operator (C++)](../debugger/context-operator-cpp.md).  
 
 ## Observing expressions with the Watch window  
  Now let's try using an expression instead. You can add any valid expression recognized by the debugger.  
@@ -118,7 +118,7 @@ int main()
  ![Watch Expression Error](../debugger/media/watchexpressionerror.png "WatchExpressionError")  
 
 ##  <a name="bkmk_refreshWatch"></a> Refreshing Watch values that are out of date  
- In certain circumstances you might see a refresh icon (a circular arrow) when an expression is evaluated in the **Watch** window.  For example, if you have property evaluation turned off (**Tools > Options > Debugging > Enable property evaluation and other implicit function calls**), and you have the following code:  
+ In certain circumstances, you might see a refresh icon (a circular arrow) when an expression is evaluated in the **Watch** window.  For example, if you have property evaluation turned off (**Tools > Options > Debugging > Enable property evaluation and other implicit function calls**), and you have the following code:  
 
 ```CSharp  
 static void Main(string[] args)  
@@ -134,17 +134,17 @@ static void Main(string[] args)
 
  ![RefreshWatch](../debugger/media/refreshwatch.png "RefreshWatch")  
 
- This indicates an error or a value that is out of date. You can generally refresh the value by clicking on the icon, but in some cases you might prefer not to refresh it. First you need to know why the value was not evaluated.  
+ The preceding illustration shows an error or a value that is out of date. You can generally refresh the value by clicking on the icon, but in some cases you might prefer not to refresh it. First you need to know why the value was not evaluated.  
 
  If you point to the icon, a tooltip provides information about why the expression was not evaluated.  If the circling arrows appear, the expression was not evaluated for one of the following reasons:  
 
 -   An error occurred as the expression was being evaluated. For example, a time-out might have occurred, or a variable might have been out of scope.  
 
--   The expression contains a function call which could trigger a side effect in the application (see [Side Effects and Expressions](#bkmk_sideEffects)).  
+-   The expression contains a function call, which could trigger a side effect in the application (see [Side Effects and Expressions](#bkmk_sideEffects)).  
 
 -   Automatic evaluation of properties and implicit functions calls by the debugger is turned off (**Tools > Options > Debugging > Enable property evaluation and other implicit function calls**), and then the expression cannot be automatically evaluated.  
 
- To refresh the value, click the refresh icon or press the spacebar. The debugger will try to reevaluate the expression. If the refresh icon appeared because automatic evaluation of properties and other implicit function calls was turned off, the expression can be evaluated.  
+ To refresh the value, click the refresh icon or press the spacebar. The debugger tries to reevaluate the expression. If the refresh icon appeared because automatic evaluation of properties and other implicit function calls was turned off, the expression can be evaluated.  
 
  If you see an icon that is a circle with two wavy lines that resemble threads, the expression was not evaluated because of a potential cross-thread dependency. In other words, evaluating the code requires other threads in your application to run temporarily. When you are in break mode, all threads in your application are typically stopped. Allowing other threads to run temporarily can have unexpected effects on the state of your program and causes the debugger to ignore events such as breakpoints and exceptions thrown on those threads.  
 
@@ -155,21 +155,22 @@ static void Main(string[] args)
 var1 = var2  
 ```  
 
- This is called  a [side effect](https://en.wikipedia.org/wiki/Side_effect_\(computer_science\)). Side effects can make debugging more difficult by changing the way your program operates.  
+ This code can cause a [side effect](https://en.wikipedia.org/wiki/Side_effect_\(computer_science\)). Side effects can make debugging more difficult by changing the way your program operates.  
 
- An expression that is known to have side effects is  evaluated only once, when you first enter it. Subsequent evaluations are disabled. You can manually override this behavior by clicking the update icon that appears next to the value.  
+ An expression that is known to have side effects is evaluated only once, when you first enter it. Subsequent evaluations are disabled. You can manually override this behavior by clicking the update icon that appears next to the value.  
 
  One way to avoid all side effects is to turn off automatic function evaluation (**Tools > Options > Debugging > Enable property evaluation and other implicit function calls**).  
 
  When evaluation of properties or implicit function calls is turned off, you can force evaluation by using the **ac** format modifier (for C# only). See [Format Specifiers in C#](../debugger/format-specifiers-in-csharp.md).  
 
 ## <a name="bkmk_objectIds"></a> Using Object IDs in the Watch window (C# and Visual Basic)  
- There are times when you want to observe the behavior of a specific object; for example, you might want to track an object referred to by a local variable after that variable has gone out of scope. In C# and Visual Basic, you can create object IDs for specific instances of reference types and use them in the Watch window and in breakpoint conditions. The object ID is generated by the common language runtime (CLR) debugging services and associated with the object.  
+
+ There are times when you want to observe the behavior of a specific object. For example, you might want to track an object referred to by a local variable after that variable has gone out of scope. In C# and Visual Basic, you can create object IDs for specific instances of reference types and use them in the Watch window and in breakpoint conditions. The object ID is generated by the common language runtime (CLR) debugging services and associated with the object.  
 
 > [!NOTE]
 >  Object IDs create weak references, and do not prevent the object from being garbage collected. They are valid only for the current debugging session.  
   
- In the following code one method creates a `Person` using a local variable, but you want to find out what the `Person`'s name is in a different method:  
+ In the following code, one method creates a `Person` using a local variable, but you want to find out what the `Person`'s name is in a different method:  
 
 ```CSharp  
 class Person  
@@ -211,24 +212,24 @@ public class Program
 
 2.  Start debugging, and when execution stops in the breakpoint, find the variable in the **Locals** window, right-click it, and select **Make Object ID**.  
 
-3.  You should see a **$** plus a number in the **Locals** window. This is the object ID.  
+3.  You should see a **$** plus a number in the **Locals** window, which represents the object ID.  
 
 4.  Add the object ID to the Watch window.  
 
-5.  Set a breakpoint where you want to observe the object's behavior.  In the code above, that would be in the `DoSomething()` method.  
+5.  Set a breakpoint where you want to observe the object's behavior.  In the preceding code, that would be in the `DoSomething()` method.  
 
 6.  Continue debugging, and when execution stops in the `DoSomething()` method, the **Watch** window displays the `Person` object.  
 
 > [!NOTE]
->  If you want to see the object's properties, such as `Person.Name` in the example above, you must have enabled property evaluation .  
+>  If you want to see the object's properties, such as `Person.Name` in the example above, you must have enabled property evaluation.  
   
 ## Using registers in the Watch window (C++ only)  
  If you are debugging native code, you can add register names as well as variable names using **$\<register name>** or **@\<register name>**.  For more information, see [Pseudovariables](../debugger/pseudovariables.md).  
 
 ## Dynamic View and the Watch window  
- Some scripting languages (e.g. JavaScript or Python) use dynamic or [duck typing](https://en.wikipedia.org/wiki/Duck_typing), and .NET languages (in version 4.0 and later) support objects that are difficult to observe using the normal debugging windows, because they may have runtime properties and methods that cannot be displayed.  
+ Some scripting languages (for example, JavaScript or Python) use dynamic or [duck typing](https://en.wikipedia.org/wiki/Duck_typing), and .NET languages (in version 4.0 and later) support objects that are difficult to observe using the normal debugging windows, because they may have runtime properties and methods that cannot be displayed.  
 
- When the Watch window displays a or an object created from a type that implements the [IDynamicMetaObjectProvider Interface](https://docs.microsoft.com/en-us/dotnet/api/system.dynamic.idynamicmetaobjectprovider?view=netframework-4.7), the debugger adds a special **Dynamic View**  node to the **Autos** display. This node shows the dynamic members of the dynamic object but does not allow editing of the member values.  
+ When the Watch window displays an object created from a type that implements the [IDynamicMetaObjectProvider Interface](https://docs.microsoft.com/en-us/dotnet/api/system.dynamic.idynamicmetaobjectprovider?view=netframework-4.7), the debugger adds a special **Dynamic View**  node to the **Autos** display. This node shows the dynamic members of the dynamic object but does not allow editing of the member values.  
 
  If you right-click any child of a **Dynamic View** and choose **Add Watch**, the debugger inserts a new watch variable that casts an object to a dynamic object. In other words, **object Name** becomes (**(dynamic)object).Name**.  
 

docs/ide/TOC.md

@@ -8,6 +8,7 @@
 ## [Synchronized Settings in Visual Studio](synchronized-settings-in-visual-studio.md)
 # [Get Started Developing with Visual Studio](get-started-developing-with-visual-studio.md)
 ## [Getting Started with Visual C# and Visual Basic](getting-started-with-visual-csharp-and-visual-basic.md)
+### [Quickstart: Create your first ASP.NET Core web app](../ide/quickstart-aspnet-core.md)
 ### [Walkthrough: Create a Simple Application with Visual C# or Visual Basic](walkthrough-create-a-simple-application-with-visual-csharp-or-visual-basic.md)
 ### [Tutorial 1: Create a Picture Viewer](tutorial-1-create-a-picture-viewer.md)
 #### [Step 1: Create a Windows Forms Application Project](step-1-create-a-windows-forms-application-project.md)