Apply suggestions from code review

Co-authored-by: Tom Dykstra <[email protected]>
Co-authored-by: Genevieve Warren <[email protected]>

docs/csharp/fundamentals/program-structure/index.md

@@ -8,7 +8,7 @@ ms.assetid: 5ae964a5-0ef0-40fe-88fb-6d1793371d0d
 ---
 # General Structure of a C# Program
 
-C# programs consists of one or more files. Each file contains zero or more namespaces. A namespace contains types such as classes, structs, interfaces, enumerations, and delegates, or other namespaces. The following example is the skeleton of a C# program that contains all of these elements.
+C# programs consist of one or more files. Each file contains zero or more namespaces. A namespace contains types such as classes, structs, interfaces, enumerations, and delegates, or other namespaces. The following example is the skeleton of a C# program that contains all of these elements.
 
 :::code language="csharp" source="snippets/toplevel-structure/Program.cs":::
 
@@ -18,7 +18,7 @@ The preceding example uses *top-level statements* for the program's entry point.
 
 ## Related Sections
 
-You learned about these program elements in the [types](../types/index.md) section of the fundamentals guide:
+You learn about these program elements in the [types](../types/index.md) section of the fundamentals guide:
 
 - [Classes](../types/classes.md)  
 - [Structs](../../language-reference/builtin-types/struct.md)  

docs/csharp/fundamentals/program-structure/main-command-line.md

@@ -35,7 +35,7 @@ For information about how to write application code with an implicit entry point
 - `Main` is declared inside a class or struct. `Main` must be [`static`](../../language-reference/keywords/static.md) and it need not be [`public`](../../language-reference/keywords/public.md). (In the earlier example, it receives the default access of [`private`](../../language-reference/keywords/private.md).) The enclosing class or struct is not required to be static.
 >>>>>>> cd631f0b85 (edit program structure)
 - `Main` can either have a `void`, `int`, or, starting with C# 7.1, `Task`, or `Task<int>` return type.
-- If and only if `Main` returns a `Task` or `Task<int>`, the declaration of `Main` may include the [`async`](../../language-reference/keywords/async.md) modifier. Note that this specifically excludes an `async void Main` method.
+- If and only if `Main` returns a `Task` or `Task<int>`, the declaration of `Main` may include the [`async`](../../language-reference/keywords/async.md) modifier. This specifically excludes an `async void Main` method.
 - The `Main` method can be declared with or without a `string[]` parameter that contains command-line arguments. When using Visual Studio to create Windows applications, you can add the parameter manually or else use the <xref:System.Environment.GetCommandLineArgs> method to obtain the command-line arguments. Parameters are read as zero-indexed command-line arguments. Unlike C and C++, the name of the program is not treated as the first command-line argument in the `args` array, but it is the first element of the <xref:System.Environment.GetCommandLineArgs> method.
 
 The following list shows valid `Main` signatures:
@@ -51,7 +51,7 @@ public static async Task Main(string[] args) { }
 public static async Task<int> Main(string[] args) { }
 ```
 
-The preceding examples all use the `public` accessor modifier. That is typical, but not required.
+The preceding examples all use the `public` accessor modifier. That's typical, but not required.
 
 The addition of `async` and `Task`, `Task<int>` return types simplifies program code when console applications need to start and `await` asynchronous operations in `Main`.
 
@@ -107,14 +107,14 @@ if ($LastExitCode -eq 0) {
 Write-Host "Return value = " $LastExitCode
 ```
 
-```txt
+```output
 Execution succeeded
 Return value = 0
 ```
 
 ### Async Main return values
 
-Async Main return values move the boilerplate code necessary for calling asynchronous methods in `Main` to code generated by the compiler. Previously, you would need to write this construct to call asynchronous code and ensure your program ran until the asynchronous operation completed:
+When you declare an `async` return value for `Main`, the compiler generates the boilerplate code for calling asynchronous methods in `Main`.  If you don't specify the `async` keyword, you need to write that code yourself, as shown in the following example. The code in the example ensures that your program runs until the asynchronous operation is completed:
 
 ```csharp
 public static void Main()
@@ -129,11 +129,11 @@ private static async Task<int> AsyncConsoleWork()
 }
 ```
 
-Now, this can be replaced by:
+This boilerplate code can be replaced by:
 
-:::code language="csharp" source="snippets/main-arguments/Program.cs":::
+:::code language="csharp" source="snippets/main-arguments/Program.cs" id="AsyncMain":::
 
-The advantage of the new syntax is that the compiler always generates the correct code.
+An advantage of declaring `Main` as `async` is that the compiler always generates the correct code.
 
 When the application entry point returns a `Task` or `Task<int>`, the compiler generates a new entry point that calls the entry point method declared in the application code. Assuming that this entry point is called `$GeneratedMain`, the compiler generates the following code for these entry points:
 
@@ -166,14 +166,14 @@ If the arguments are not used, you can omit `args` from the method signature for
 | Return value, uses `await`         | `static async Task<int> Main()` |
 
 > [!NOTE]
-> To enable command-line arguments in the `Main` method in a Windows Forms application, you must manually modify the signature of `Main` in *program.cs*. The code generated by the Windows Forms designer creates a `Main` without an input parameter. You can also use <xref:System.Environment.CommandLine%2A?displayProperty=nameWithType> or <xref:System.Environment.GetCommandLineArgs%2A?displayProperty=nameWithType> to access the command-line arguments from any point in a console or Windows application.
+> You can also use <xref:System.Environment.CommandLine%2A?displayProperty=nameWithType> or <xref:System.Environment.GetCommandLineArgs%2A?displayProperty=nameWithType> to access the command-line arguments from any point in a console or Windows Forms application. To enable command-line arguments in the `Main` method signature in a Windows Forms application, you must manually modify the signature of `Main`. The code generated by the Windows Forms designer creates `Main` without an input parameter.
 
 The parameter of the `Main` method is a <xref:System.String> array that represents the command-line arguments. Usually you determine whether arguments exist by testing the `Length` property, for example:
 
 :::code language="csharp" source="snippets/main-command-line/Program.cs" ID="Snippet4":::
 
 > [!TIP]
-> The `args` array cannot be null. So, it's safe to access the `Length` property without null checking.
+> The `args` array can't be null. So, it's safe to access the `Length` property without null checking.
 
 You can also convert the string arguments to numeric types by using the <xref:System.Convert> class or the `Parse` method. For example, the following statement converts the `string` to a `long` number by using the <xref:System.Int64.Parse%2A> method:
 

docs/csharp/fundamentals/program-structure/top-level-statements.md

@@ -6,7 +6,7 @@ helpviewer_keywords:
   - "C# language, top-level statements"
   - "C# language, Main method"
 ---
-# Top-level statements - programs without Main methods
+# Top-level statements - programs without `Main` methods
 
 Starting in C# 9, you don't have to explicitly include a `Main` method in a console application project. Instead, you can use the *top-level statements* feature to minimize the code you have to write. In this case, the compiler generates a class and `Main` method entry point for the application.
 

docs/csharp/fundamentals/types/index.md

@@ -142,7 +142,7 @@ It can be inconvenient to create a named type for simple sets of related values
 
 Ordinary value types can't have a value of [`null`](../../language-reference/keywords/null.md). However, you can create *nullable value types* by appending a `?` after the type. For example, `int?` is an `int` type that can also have the value [`null`](../../language-reference/keywords/null.md). Nullable value types are instances of the generic struct type <xref:System.Nullable%601?displayProperty=nameWithType>. Nullable value types are especially useful when you're passing data to and from databases in which numeric values might be `null`. For more information, see [Nullable value types](../../language-reference/builtin-types/nullable-value-types.md).
 
-## Compile-time type and runtime type
+## Compile-time type and run-time type
 
 A variable can have different compile-time and run-time types. The *compile-time type* is the declared or inferred type of the variable in the source code. The *run-time type* is the type of the instance referred to by that variable. Often those two types are the same, as in the following example: