Apply suggestions from code review

A very thorough early review from Ron

Co-Authored-By: BillWagner <wiwagn@microsoft.com>

Author: Ron Petrusha

docs/csharp/tutorials/exploration/csharp-7.yml

@@ -40,7 +40,7 @@ items:
     * No need to assign an initial value.
         - By declaring the `out` variable where it is used in a method call, you can't accidentally use it before it is assigned.
 
-    The most common use for this feature will be the `Try` pattern. In this
+    The most common use for this feature is in the `Try` pattern. In this
     pattern, a method returns a `bool` indicating success or failure and an
     `out` variable that provides the result if the method succeeds.
 
@@ -64,20 +64,20 @@ items:
     > on platforms that do not include the types.
     >
     > This is similar to other language features that rely on types
-    > delivered in the framework. Example include `async` and `await`
+    > delivered in the framework. Examples include `async` and `await`
     > relying on the `INotifyCompletion` interface, and LINQ relying
     > on `IEnumerable<T>`. However, the delivery mechanism is changing
     > as .NET is becoming more platform independent. The .NET Framework
     > may not always ship on the same cadence as the language compiler. When new language
     > features rely on new types, those types will be available as NuGet packages when
-    > the language features ship. As these new types get added to the .NET Standard
-    > API and delivered as part of the framework, the NuGet package requirement will
+    > the language features ship. As these new types are added to the .NET Standard
+    > Library and delivered as part of the framework, the NuGet package requirement will
     > be removed.
 
-    C# provides a rich syntax for classes and structs that is used to explain
+    C# provides a rich syntax for classes and structs that explains
     your design intent. But sometimes that rich syntax requires extra
     work with minimal benefit. You may often write methods that need a simple
-    structure containing more than one data element. To support these scenarios
+    structure containing more than one data element. To support these scenarios,
     *tuples* were added to C#. Tuples are lightweight data structures
     that contain multiple fields to represent the data members.
     The fields are not validated, and you cannot define your own methods
@@ -103,7 +103,7 @@ items:
 
     The `namedLetters` tuple contains fields referred to as `Alpha` and
     `Beta`. Those names exist only at compile time and are not preserved
-    for example when inspecting the tuple using reflection at runtime.
+when inspecting the tuple using reflection at runtime, for example.
 
     In a tuple assignment, you can also specify the names of the fields
     on the right-hand side of the assignment:
@@ -116,17 +116,17 @@ items:
     [!code-csharp[NamedTupleConflict](~/samples/snippets/csharp/new-in-7/program.cs#07_NamedTupleConflict "Named tuple conflict")]
 
     The line above generates a warning, `CS8123`, telling you that the names on the right
-    side of the assignment, `Alpha` and `Beta` are ignored because they conflict
+    side of the assignment, `Alpha` and `Beta`, are ignored because they conflict
     with the names on the left side, `First` and `Second`.
 
     The examples above show the basic syntax to declare tuples. Tuples are
     most useful as return types for `private` and `internal` methods. Tuples
     provide a simple syntax for those methods to return multiple discrete values:
     You save the work of authoring a `class` or a `struct` that
-    defines the type returned. There is no need for creating a new type.
+    defines the type returned. There is no need to create a new type.
 
     Creating a tuple is more efficient and more productive.
-    It is a simpler, lightweight syntax to define a data structure that carries
+    It has a simpler, lightweight syntax to define a data structure that carries
     more than one value. The example method below returns the minimum and maximum
     values found in a sequence of integers:
 
@@ -136,7 +136,7 @@ items:
 
     * You save the work of authoring a `class` or a `struct` that defines the type returned. 
     * You do not need to create new type.
-    * The language enhancements removes the need to call the <xref:System.Tuple.Create``1(``0)> methods.
+    * The language enhancements removes the need to call the <xref:System.Tuple.Create``1(``0)?displayProperty=nameWithType> methods.
 
     The declaration for the method provides the names for the fields of the
     tuple that is returned. When you call the method, the return value is a 
@@ -174,7 +174,7 @@ items:
 - title: Use discards to select needed members
   durationInMinutes: 2
   content: |
-    Often when deconstructing a tuple or calling a method with `out` parameters, you're forced to define a variable whose value you don't care about and don't intend to use. C# adds support for *discards* to handle this scenario. A discard is a write-only variable whose name is `_` (the underscore character); you can assign all of the values that you intend to discard to the single variable. A discard is like an unassigned variable; apart from the assignment statement, the discard can't be used in code.
+    Often when deconstructing a tuple or calling a method with `out` parameters, you're forced to define a variable whose value you don't care about and don't intend to use. C# adds support for *discards* to handle this scenario. A discard is a write-only variable whose name is `_` (the underscore character); you can assign all of the values that you intend to discard to the single variable. A discard is like an unassigned variable; apart from the assignment, the discard can't be used in code.
 
     Discards are supported in the following scenarios:
 
@@ -186,7 +186,7 @@ items:
 
     * As a standalone identifier when you want to explicitly identify the value of an assignment as a discard.
 
-    The following example defines a `QueryCityDataForYears` method that returns a 6-tuple that contains a data for a city for two different years. The method call in the example is concerned only with the two population values returned by the method and so treats the remaining values in the tuple as discards when it deconstructs the tuple.
+    The following example defines a `QueryCityDataForYears` method that returns a 6-tuple that contains data for a city for two different years. The method call in the example is concerned only with the two population values returned by the method and so treats the remaining values in the tuple as discards when it deconstructs the tuple.
 
     [!code-csharp[Tuple-discard](~/samples/snippets/csharp/programming-guide/deconstructing-tuples/discard-tuple1.cs)]
 
@@ -197,16 +197,16 @@ items:
   content: |
     *Pattern matching* is a feature that allows you to implement method dispatch on
     properties other than the type of an object. You're probably already familiar
-    with method dispatch based on the type of an object. In Object Oriented programming,
+    with method dispatch based on the type of an object. In object oriented programming,
     virtual and override methods provide language syntax to implement method dispatching
-    based on an object's type. Base and Derived classes provide different implementations. 
+    based on an object's type. Base and derived classes provide different implementations. 
     Pattern matching expressions extend this concept so that you can easily
     implement similar dispatch patterns for types and data elements that are
     not related through an inheritance hierarchy. 
 
     Pattern matching supports `is` expressions and `switch` expressions. Each
     enables inspecting an object and its properties to determine if that object
-    satisfies the sought pattern. You use the `when` keyword to specify additional
+    satisfies the desired pattern. You use the `when` keyword to specify additional
     rules to the pattern.
 
     ### `is` expression
@@ -299,18 +299,18 @@ items:
   content: |
     This feature enables algorithms that use and return references
     to variables defined elsewhere. One example is working with
-    large matrices, and finding a single location with certain
+    large matrices and finding a single location with certain
     characteristics. One method would return the two indices for
     a single location in the matrix:
 
     [!code-csharp[FindReturningIndices](~/samples/snippets/csharp/new-in-7/MatrixSearch.cs#20_FindReturningIndices "Find returning indices")]
 
     There are many issues with this code. First of all, it's a public
-    method that's returning a tuple. The language supports this, but
-    user defined types (either classes or structs) are preferred
+    method that returns a tuple. The language supports this, but
+    user-defined types (either classes or structs) are preferred
     for public APIs.
 
-    Second, this method is returning the indices to the item in the matrix.
+    Second, this method returns the indices to the item in the matrix.
     That leads callers to write code that uses those indices to dereference
     the matrix and modify a single element:
 
@@ -323,7 +323,7 @@ items:
     Let's walk through a series of changes to demonstrate the ref local feature
     and show how to create a method that returns a reference to internal storage.
     Along the way, you'll learn the rules of the ref return and ref local feature that
-    protects you from accidentally misusing it.
+    protect you from accidentally misusing it.
 
     Start by modifying the `Find` method declaration so that it returns a `ref int`
     instead of a tuple. Then, modify the return statement so it returns the value
@@ -369,11 +369,11 @@ items:
 
     [!code-csharp[AssignRefReturn](~/samples/snippets/csharp/new-in-7/program.cs#24_AssignRefReturn "Assign ref return")]
 
-    Now, the second `WriteLine` statement in the example above will print 
+    Now, the second `WriteLine` statement in the example above prints 
     out the value `24`, indicating that the storage in the matrix has been
     modified. The local variable has been declared with the `ref` modifier,
     and it will take a `ref` return. You must initialize a `ref` variable when
-    it is declared, you cannot split the declaration and the initialization.
+    it is declared; you cannot split the declaration and the initialization.
 
     The C# language has three other rules that protect you from misusing
     the `ref` locals and returns:
@@ -399,7 +399,7 @@ items:
     Many designs for classes include methods that are called from only
     one location. These additional private methods keep each method small
     and focused. However, they can make it harder to understand a class
-    when reading it the first time. These methods must be understood
+    when reading it the first time, since these methods are understood
     outside of the context of the single calling location.
 
     For those designs, *local functions* enable you to declare methods
@@ -461,9 +461,9 @@ items:
     > [!NOTE]
     > Some of the designs that are supported by local functions
     > could also be accomplished using *lambda expressions*. Those
-    > interested can [read more about the differences](../../local-functions-vs-lambdas.md)
+    > interested can [read more about the differences](../../local-functions-vs-lambdas.md).
 
-- title: Throw expressions more concise error reporting
+- title: Throw expressions allow more concise error reporting
   durationInMinutes: 2
   content: |
     In C#, `throw` has always been a statement. Because `throw` is a statement,