Merge pull request #6020 from dotnet/master

Update live with current master

Author: mairaw

.openpublishing.redirection.json

@@ -1309,6 +1309,10 @@
         {
             "source_path":"docs/framework/windows-workflow-foundation/samples/using-the-invokemethod-activity.md",
             "redirect_url":"/dotnet/framework/windows-workflow-foundation/samples/built-in-activities"
+        },
+        {
+            "source_path":"docs/fsharp/language-reference/signatures.md",
+            "redirect_url":"/dotnet/fsharp/language-reference/signature-files"
         }
     ]
 }

docs/core/migration/20-21.md

@@ -0,0 +1,32 @@
+---
+title: Migrate from .NET Core 2.0 to 2.1
+description: Learn how to upgrade your .NET Core 2.0 app to 2.1.
+author: mairaw
+ms.author: mairaw
+ms.date: 06/18/2018
+---
+# Migrate from .NET Core 2.0 to 2.1
+
+This article shows you the basic steps for migrating your .NET Core 2.0 app to 2.1. If you're looking to migrate your ASP.NET Core app to 2.1, see [Migrate from ASP.NET Core 2.0 to 2.1](/aspnet/core/migration/20_21).
+
+For an overview of the new features in .NET Core 2.1, see [What's new in .NET Core 2.1](../whats-new/dotnet-core-2-1.md).
+
+## Update the project file to use 2.1 versions
+
+* Open the project file (the \*.csproj, \*.vbproj, or \*.fsproj file).
+
+* Change the [target framework](../../standard/frameworks.md) value from `netcoreapp2.0` to `netcoreapp2.1`. The target framework is defined by the `<TargetFramework>` or `<TargetFrameworks>` element.
+
+For example, change `<TargetFramework>netcoreapp2.0</TargetFramework>` to `<TargetFramework>netcoreapp2.1</TargetFramework>`.
+
+* Remove `<DotNetCliToolReference>` references for tools that are bundled in the .NET Core 2.1 SDK (v 2.1.300 or later). These references include:
+
+  * [dotnet-watch](https://github.com/aspnet/DotNetTools/blob/dev/src/dotnet-watch/README.md) (Microsoft.DotNet.Watcher.Tools)
+  * [dotnet-user-secrets](https://github.com/aspnet/DotNetTools/blob/dev/src/dotnet-user-secrets/README.md) (Microsoft.Extensions.SecretManager.Tools)
+  * [dotnet-sql-cache](https://github.com/aspnet/DotNetTools/blob/dev/src/dotnet-sql-cache/README.md) (Microsoft.Extensions.Caching.SqlConfig.Tools)
+  * [dotnet-ef](/ef/core/miscellaneous/cli/dotnet) (Microsoft.EntityFrameworkCore.Tools.DotNet)
+
+## See also
+
+[Migrate from ASP.NET Core 2.0 to 2.1](/aspnet/core/migration/20_21)  
+[What's new in .NET Core 2.1](../whats-new/dotnet-core-2-1.md)  

docs/csharp/expression-trees-building.md

@@ -51,10 +51,10 @@ Once you've got the addition expression, you can create the lambda
 expression:
 
 ```csharp
-var lamdba = Expression.Lambda(addition);
+var lambda = Expression.Lambda(addition);
 ```
 
-This is a very simple LambdaExpression, because it contains no arguments.
+This is a very simple lambda expression, because it contains no arguments.
 Later in this section, you'll see how to map arguments to parameters
 and build more complicated expressions.
 

docs/csharp/expression-trees-execution.md

@@ -12,16 +12,18 @@ ms.assetid: 109e0ac5-2a9c-48b4-ac68-9b6219cdbccf
 An *expression tree* is a data structure that represents some code.
 It is not compiled and executable code. If you want to execute
 the .NET code that is represented by an expression tree, you must
-convert it into executable IL instructions. 
+convert it into executable IL instructions.
+
 ## Lambda Expressions to Functions
+
 You can convert any LambdaExpression, or any type derived from
 LambdaExpression into executable IL. Other expression types
 cannot be directly converted into code. This restriction has
 little effect in practice. Lambda expressions are the only
 types of expressions that you would want to execute by converting
 to executable intermediate language (IL). (Think about what it would mean
 to directly execute a `ConstantExpression`. Would it mean
-anything useful?) Any expression tree that is a `LamdbaExpression`,
+anything useful?) Any expression tree that is a `LambdaExpression`,
 or a type derived from `LambdaExpression` can be converted to IL.
 The expression type `Expression<TDelegate>`
 is the only concrete example in the .NET Core libraries. It's used
@@ -35,15 +37,14 @@ and its corresponding delegate. For example, an expression tree that
 is represented by `Expression<Func<int>>` would be converted to a delegate
 of the type `Func<int>`. For a lambda expression with any return type
 and argument list, there exists a delegate type that is the target type
-for the executable code represented by that lamdba expression.
+for the executable code represented by that lambda expression.
 
-The `LamdbaExpression` type contains `Compile` and `CompileToMethod`
+The `LambdaExpression` type contains `Compile` and `CompileToMethod`
 members that you would use to convert an expression tree to executable
 code. The `Compile` method creates a delegate. The `CompileToMethod`
 method updates a `MethodBuilder` object with the IL that represents
 the compiled output of the expression tree. Note that `CompileToMethod`
-is only available on the full desktop framework, not on the 
-.NET Core framework.
+is only available in the full desktop framework, not in the .NET Core.
 
 Optionally, you can also provide a `DebugInfoGenerator` that will
 receive the symbol debugging information for the generated delegate
@@ -65,13 +66,13 @@ Notice that the delegate type is based on the expression type. You must
 know the return type and the argument list if you want to use the
 delegate object in a strongly typed manner. The `LambdaExpression.Compile()`
 method returns the `Delegate` type. You will have to cast it to the correct
-delegate type to have any compile-time tools check the argument list of
+delegate type to have any compile-time tools check the argument list or
 return type.
 
 ## Execution and Lifetimes
 
 You execute the code by invoking the delegate created when
-you called `LamdbaExpression.Compile()`. You can see this above where
+you called `LambdaExpression.Compile()`. You can see this above where
 `add.Compile()` returns a delegate. Invoking that delegate, by calling
 `func()` executes the code.
 

docs/csharp/indexers.md

@@ -212,7 +212,7 @@ from any users of this class.
 Another common scenario is when you need to model a dictionary
 or a map. This scenario is when your type stores values based on key,
 typically text keys. This example creates a dictionary that maps command
-line arguments to [lamdba expressions](delegates-overview.md) that manage
+line arguments to [lambda expressions](delegates-overview.md) that manage
 those options. The following example shows two classes: an `ArgsActions`
 class that maps a command line option to an `Action` delegate, and an
 `ArgsProcessor` that uses the `ArgsActions` to execute each `Action` when

docs/csharp/language-reference/keywords/virtual.md

@@ -36,7 +36,7 @@ public virtual double Area()
 -   A virtual inherited property can be overridden in a derived class by including a property declaration that uses the `override` modifier.  
 
 ## Example  
- In this example, the `Shape` class contains the two coordinates `x`, `y`, and the `Area()` virtual method. Different shape classes such as `Circle`, `Cylinder`, and `Sphere` inherit the `Shape` class, and the surface area is calculated for each figure. Each derived class has it own override implementation of `Area()`.  
+ In this example, the `Shape` class contains the two coordinates `x`, `y`, and the `Area()` virtual method. Different shape classes such as `Circle`, `Cylinder`, and `Sphere` inherit the `Shape` class, and the surface area is calculated for each figure. Each derived class has its own override implementation of `Area()`.  
 
  Notice that the inherited classes `Circle`, `Sphere`, and `Cylinder` all use constructors that initialize the base class, as shown in the following declaration.  
 

docs/csharp/programming-guide/index.md

@@ -13,7 +13,7 @@ ms.assetid: ac0f23a2-6bf3-4077-be99-538ae5fd3bc5
 # C# programming guide
 This section provides detailed information on key C# language features and features accessible to C# through the .NET Framework.  
 
- Most of this section assumes that you already know something about C# and general programming concepts. If you are a complete beginner with programming or with C#, you might want to visit the [Getting Started with C#](https://www.microsoft.com/net/tutorials/csharp/getting-started) interactive tutorial, where no prior programming knowledge is required.  
+ Most of this section assumes that you already know something about C# and general programming concepts. If you are a complete beginner with programming or with C#, you might want to visit the [C# Quickstarts](../quick-starts/index.md) or [Getting Started with C#](https://www.microsoft.com/net/tutorials/csharp/getting-started) interactive tutorial, where no prior programming knowledge is required.  
 
  For information about specific keywords, operators and preprocessor directives, see [C# Reference](../../csharp/language-reference/index.md). For information about the C# Language Specification, see [C# Language Specification](../../csharp/language-reference/language-specification/index.md).