1769497, fixed typos.

john-par · john-par · commit 1edcaa4c9a0c · 2020-09-24T13:28:51.000-07:00
diff --git a/docs/dotnet/how-to-declare-override-specifiers-in-native-compilations-cpp-cli.md b/docs/dotnet/how-to-declare-override-specifiers-in-native-compilations-cpp-cli.md
@@ -62,7 +62,7 @@ public:
 };
 ```
 
-## Example showing that abstract is valid
+## Example showing abstract is valid
 
 ### Description
 
diff --git a/docs/dotnet/how-to-extend-the-marshaling-library.md b/docs/dotnet/how-to-extend-the-marshaling-library.md
@@ -95,7 +95,7 @@ namespace msclr {
 }
 ```
 
-## Example extending the marshaling library
+## Example extending marshaling library
 
 The following example extends the marshaling library with a conversion that does not require a context. In this example, the code converts the employee information from a native data type to a managed data type.
 
@@ -157,7 +157,7 @@ Managed address: 123 Main Street
 Managed zip code: 98111
 ```
 
-## Example converting the employee information
+## Example converting employee information
 
 The following example converts the employee information from a managed data type to a native data type. This conversion requires a marshaling context.
 
diff --git a/docs/dotnet/how-to-marshal-ansi-strings-using-cpp-interop.md b/docs/dotnet/how-to-marshal-ansi-strings-using-cpp-interop.md
@@ -15,7 +15,7 @@ This topic demonstrates how ANSI strings can be passed using C++ Interop, but th
 
 The following code examples use the [managed, unmanaged](../preprocessor/managed-unmanaged.md) #pragma directives to implement managed and unmanaged functions in the same file, but these functions interoperate in the same manner if defined in separate files. Because files containing only unmanaged functions do not need to be compiled with [/clr (Common Language Runtime Compilation)](../build/reference/clr-common-language-runtime-compilation.md), they can retain their performance characteristics.
 
-## Example passing an ANSI string
+## Example passing ANSI string
 
 The example demonstrates passing an ANSI string from a managed to an unmanaged function using <xref:System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi%2A>. This method allocates memory on the unmanaged heap and returns the address after performing the conversion. This means that no pinning is necessary (because memory on the GC heap is not being passed to the unmanaged function) and that the IntPtr returned from <xref:System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi%2A> must be explicitly released or a memory leak results.
 
@@ -49,7 +49,7 @@ int main() {
 }
 ```
 
-## Example of data marshaling required to access an ANSI string
+## Example of data marshaling required to access ANSI string
 
 The following example demonstrates the data marshaling required to access an ANSI string in a managed function that is called by an unmanaged function. The managed function, on receiving the native string, can either use it directly or convert it to a managed string using the <xref:System.Runtime.InteropServices.Marshal.PtrToStringAnsi%2A> method, as shown.
 
diff --git a/docs/dotnet/how-to-marshal-arrays-using-cpp-interop.md b/docs/dotnet/how-to-marshal-arrays-using-cpp-interop.md
@@ -11,7 +11,7 @@ This topic demonstrates one facet of Visual C++ interoperability. For more infor
 
 The following code examples use the [managed, unmanaged](../preprocessor/managed-unmanaged.md) #pragma directives to implement managed and unmanaged functions in the same file, but these functions interoperate in the same manner if defined in separate files. Files containing only unmanaged functions do not need to be compiled with [/clr (Common Language Runtime Compilation)](../build/reference/clr-common-language-runtime-compilation.md).
 
-## Example passing a managed array to an unmanaged function
+## Example passing managed array to unmanaged function
 
 The following example demonstrates how to pass a managed array to an unmanaged function. The managed function uses [pin_ptr (C++/CLI)](../extensions/pin-ptr-cpp-cli.md) to suppress garbage collection for the array before calling the unmanaged function. By providing the unmanaged function with a pinned pointer into the GC heap, the overhead of making a copy of the array can be avoided. To demonstrate that the unmanaged function is accessing GC heap memory, it modifies the contents of the array and the changes are reflected when the managed function resumes control.
 
@@ -70,7 +70,7 @@ int main() {
 }
 ```
 
-## Example passing an unmanaged array to a managed function
+## Example passing unmanaged array to managed function
 
 The following example demonstrates passing an unmanaged array to a managed function. The managed function accesses the array memory directly (as opposed to creating a managed array and copying the array content), which allows changes made by the managed function to be reflected in the unmanaged function when it regains control.
 
diff --git a/docs/dotnet/how-to-marshal-callbacks-and-delegates-by-using-cpp-interop.md b/docs/dotnet/how-to-marshal-callbacks-and-delegates-by-using-cpp-interop.md
@@ -11,7 +11,7 @@ This topic demonstrates the marshalling of callbacks and delegates (the managed
 
 The following code examples use the [managed, unmanaged](../preprocessor/managed-unmanaged.md) #pragma directives to implement managed and unmanaged functions in the same file, but the functions could also be defined in separate files. Files containing only unmanaged functions do not need to be compiled with the [/clr (Common Language Runtime Compilation)](../build/reference/clr-common-language-runtime-compilation.md).
 
-## Example configuring an unmanaged API to trigger a managed delegate
+## Example configuring unmanaged API to trigger managed delegate
 
 The following example demonstrates how to configure an unmanaged API to trigger a managed delegate. A managed delegate is created and one of the interop methods, <xref:System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate%2A>, is used to retrieve the underlying entry point for the delegate. This address is then passed to the unmanaged function, which calls it with no knowledge of the fact that it is implemented as a managed function.
 
@@ -65,7 +65,7 @@ int main() {
 }
 ```
 
-## Example with the function pointer stored by the unmanaged API
+## Example with function pointer stored by unmanaged API
 
 The following example is similar to the previous example, but in this case the provided function pointer is stored by the unmanaged API, so it can be invoked at any time, requiring that garbage collection be suppressed for an arbitrary length of time. As a result, the following example uses a global instance of <xref:System.Runtime.InteropServices.GCHandle> to prevent the delegate from being relocated, independent of function scope. As discussed in the first example, using pin_ptr is unnecessary for these examples, but in this case wouldn't work anyway, as the scope of a pin_ptr is limited to a single function.
 
diff --git a/docs/dotnet/how-to-marshal-com-strings-using-cpp-interop.md b/docs/dotnet/how-to-marshal-com-strings-using-cpp-interop.md
@@ -15,7 +15,7 @@ This topic demonstrates how a BSTR (the basic string format favored in COM progr
 
 The following code examples use the [managed, unmanaged](../preprocessor/managed-unmanaged.md) #pragma directives to implement managed and unmanaged functions in the same file, but these functions interoperate in the same manner if defined in separate files. Files containing only unmanaged functions do not need to be compiled with [/clr (Common Language Runtime Compilation)](../build/reference/clr-common-language-runtime-compilation.md).
 
-## Example passing a BSTR from a managed to an unmanaged function
+## Example passing BSTR from managed to unmanaged function
 
 The following example demonstrates how a BSTR (a string format used in COM programming) can be passed from a managed to an unmanaged function. The calling managed function uses <xref:System.Runtime.InteropServices.Marshal.StringToBSTR%2A> to obtain the address of a BSTR representation of the contents of a .NET System.String. This pointer is pinned using [pin_ptr (C++/CLI)](../extensions/pin-ptr-cpp-cli.md) to ensure that its physical address is not changed during a garbage collection cycle while the unmanaged function executes. The garbage collector is prohibited from moving the memory until the [pin_ptr (C++/CLI)](../extensions/pin-ptr-cpp-cli.md) goes out of scope.
 
@@ -52,7 +52,7 @@ int main() {
 }
 ```
 
-## Example passing a BSTR from a an unmanaged to a managed function
+## Example passing BSTR from unmanaged to managed function
 
 The following example demonstrates how a BSTR can be passed from an unmanaged to an unmanaged function. The receiving managed function can either use the string in as a BSTR or use <xref:System.Runtime.InteropServices.Marshal.PtrToStringBSTR%2A> to convert it to a <xref:System.String> for use with other managed functions. Because the memory representing the BSTR is allocated on the unmanaged heap, no pinning is necessary, because there is no garbage collection on the unmanaged heap.
 
diff --git a/docs/dotnet/how-to-marshal-structures-using-cpp-interop.md b/docs/dotnet/how-to-marshal-structures-using-cpp-interop.md
@@ -11,7 +11,7 @@ This topic demonstrates one facet of Visual C++ interoperability. For more infor
 
 The following code examples use the [managed, unmanaged](../preprocessor/managed-unmanaged.md) #pragma directives to implement managed and unmanaged functions in the same file, but these functions interoperate in the same manner if defined in separate files. Files containing only unmanaged functions do not need to be compiled with [/clr (Common Language Runtime Compilation)](../build/reference/clr-common-language-runtime-compilation.md).
 
-## Example passing a structure from a managed to an unmanaged function
+## Example passing structure from managed to unmanaged function
 
 The following example demonstrates passing a structure from a managed to an unmanaged function, both by value and by reference. Because the structure in this example contains only simple, intrinsic data types (see [Blittable and Non-Blittable Types](/dotnet/framework/interop/blittable-and-non-blittable-types)), no special marshaling is required. To marshal non-blittable structures, such as those that contain pointers, see [How to: Marshal Embedded Pointers Using C++ Interop](../dotnet/how-to-marshal-embedded-pointers-using-cpp-interop.md).
 
@@ -69,7 +69,7 @@ int main() {
 }
 ```
 
-## Example passing a structure from an unmanaged to a managed function
+## Example passing structure from unmanaged to managed function
 
 The following example demonstrates passing a structure from an unmanaged to a managed function, both by value and by reference. Because the structure in this example contains only simple, intrinsic data types (see [Blittable and Non-Blittable Types](/dotnet/framework/interop/blittable-and-non-blittable-types)), no special marshalling is required. To marshal non-blittable structures, such as those that contain pointers, see [How to: Marshal Embedded Pointers Using C++ Interop](../dotnet/how-to-marshal-embedded-pointers-using-cpp-interop.md).
 
diff --git a/docs/dotnet/how-to-marshal-unicode-strings-using-cpp-interop.md b/docs/dotnet/how-to-marshal-unicode-strings-using-cpp-interop.md
@@ -17,7 +17,7 @@ This topic demonstrates how Unicode strings can be passed from a managed to an u
 
 - [How to: Marshal COM Strings Using C++ Interop](../dotnet/how-to-marshal-com-strings-using-cpp-interop.md)
 
-## Example passing a Unicode string from a managed to an unmanaged function
+## Example passing Unicode string from managed to unmanaged function
 
 To pass a Unicode string from a managed to an unmanaged function, the PtrToStringChars function (declared in Vcclr.h) can be used to access in the memory where the managed string is stored. Because this address will be passed to a native function, it is important that the memory be pinned with [pin_ptr (C++/CLI)](../extensions/pin-ptr-cpp-cli.md) to prevent the string data from being relocated, should a garbage collection cycle take place while the unmanaged function executes.
 
@@ -50,7 +50,7 @@ int main() {
 }
 ```
 
-## Example with data marshaling required to access a Unicode string
+## Example with data marshaling required to access Unicode string
 
 The following example demonstrates the data marshaling required to access a Unicode string in a managed function called by an unmanaged function. The managed function, on receiving the native Unicode string, converts it to a managed string using the <xref:System.Runtime.InteropServices.Marshal.PtrToStringUni%2A> method.
 
diff --git a/docs/extensions/consuming-generics-cpp-cli.md b/docs/extensions/consuming-generics-cpp-cli.md
@@ -9,7 +9,7 @@ ms.assetid: e6330ef5-e907-432e-b527-7a22f5899639
 
 Generics authored in one .NET (or UWP) language may be used in other languages. Unlike templates, a generic in a compiled assembly still remains generic. Thus, one may instantiate the generic type in a different assembly and even in a different language than the assembly in which the generic type was defined.
 
-## Example of a generic class defined in C#
+## Example of generic class defined in C#
 
 ### Description
 
@@ -73,7 +73,7 @@ public class CircularList<ItemType> {
 }
 ```
 
-## Example consumes the assembly authored in C#
+## Example consumes assembly authored in C#
 
 ### Description
 
diff --git a/docs/extensions/generic-classes-cpp-cli.md b/docs/extensions/generic-classes-cpp-cli.md
@@ -272,7 +272,7 @@ The signature of a non-generic method can include one or more type parameters of
 
 The body of such methods can also use these type parameters.
 
-## Example declaring a non-generic method
+## Example declaring non-generic method
 
 The following example declares a non-generic method, `ProtectData`, inside a generic class, `MyClass<ItemType>`. The method uses the class type parameter `ItemType` in its signature in an open constructed type.
 
@@ -443,7 +443,7 @@ Since there is no way to refer to the outer type parameter, the compiler will pr
 
 When constructed nested generic types are named, the type parameter for the outer type is not included in the type parameter list for the inner type, even though the inner type is implicitly parameterized by the outer type's type parameter. In the above case, a name of a constructed type would be `Outer<int>::Inner<string>`.
 
-## Example building and reading a linked list
+## Example building and reading linked list
 
 The following example demonstrates building and reading a linked list using nested types in generic classes.
 
@@ -546,7 +546,7 @@ Reading nodes:
 
 - Properties, events, indexers and operators cannot themselves be parameterized.
 
-## Example declaring an instance property
+## Example declaring instance property
 
 This example shows declarations of an instance property within a generic class.
 
@@ -586,7 +586,7 @@ int main() {
 John, 234
 ```
 
-## Example of a generic class with an event
+## Example of generic class with event
 
 The next example shows a generic class with an event.
 
@@ -653,7 +653,7 @@ int main() {
 
 The rules for declaring and using generic structs are the same as those for generic classes, except for the differences noted in the Visual C++ language reference.
 
-## Example declaring a generic struct
+## Example declaring generic struct
 
 The following example declares a generic struct, `MyGenStruct`, with one field, `myField`, and assigns values of different types (**`int`**, **`double`**, `String^`) to this field.
 
diff --git a/docs/extensions/how-to-declare-value-types-with-the-interior-ptr-keyword-cpp-cli.md b/docs/extensions/how-to-declare-value-types-with-the-interior-ptr-keyword-cpp-cli.md
@@ -12,7 +12,7 @@ An **interior_ptr** can be used with a value type.
 > [!IMPORTANT]
 > This language feature is supported by the `/clr` compiler option, but not by the `/ZW` compiler option.
 
-## Example using interior_ptr with a value type
+## Example using interior_ptr with value type
 
 ### Description
 
diff --git a/docs/extensions/how-to-improve-performance-with-generics-visual-cpp.md b/docs/extensions/how-to-improve-performance-with-generics-visual-cpp.md
@@ -11,7 +11,7 @@ With generics, you can create reusable code based on a type parameter. The actua
 
 This article will discuss how generics can help increase the performance of an application that uses collections.
 
-## Example showing the two main drawbacks of the .NET Framework collections
+## Example showing two main drawbacks of .NET Framework collections
 
 The .NET Framework comes with many collection classes in the <xref:System.Collections?displayProperty=fullName> namespace. Most of these collections operate on objects of type <xref:System.Object?displayProperty=fullName>. This allows collections to store any type, since all types in the .NET Framework, even value types, derive from <xref:System.Object?displayProperty=fullName>. However, there are two drawbacks to this approach.
 
@@ -68,7 +68,7 @@ Popped a String: Seven
 Popped an int: 7
 ```
 
-## Example showing the benefit of using a generic collection
+## Example showing the benefit of using generic collection
 
 The new <xref:System.Collections.Generic?displayProperty=fullName> namespace contains many of the same collections found in the <xref:System.Collections?displayProperty=fullName> namespace, but they have been modified to accept generic type parameters. This eliminates the two drawbacks of non-generic collections: the boxing and unboxing of value types and the inability to specify the types to be stored in the collections. Operations on the two collections are identical; they differ only in how they are instantiated.
 
diff --git a/docs/parallel/concrt/how-to-create-a-task-that-completes-after-a-delay.md b/docs/parallel/concrt/how-to-create-a-task-that-completes-after-a-delay.md
@@ -8,7 +8,7 @@ ms.assetid: 3fc0a194-3fdb-4eba-8b8a-b890981a985d
 
 This example shows how to use the [concurrency::task](../../parallel/concrt/reference/task-class.md), [concurrency::cancellation_token_source](../../parallel/concrt/reference/cancellation-token-source-class.md), [concurrency::cancellation_token](../../parallel/concrt/reference/cancellation-token-class.md), [concurrency::task_completion_event](../../parallel/concrt/reference/task-completion-event-class.md), [concurrency::timer](../../parallel/concrt/reference/timer-class.md), and [concurrency::call](../../parallel/concrt/reference/call-class.md) classes to create a task that completes after a delay. You can use this method to build loops that occasionally poll for data, introduce timeouts, delay handling of user input for a predetermined time, and so on.
 
-## Example using the the complete_after and cancel_after_timeout functions
+## Example using complete_after and cancel_after_timeout functions
 
 The following example shows the `complete_after` and `cancel_after_timeout` functions. The `complete_after` function creates a `task` object that completes after the specified delay. It uses a `timer` object and a `call` object to set a `task_completion_event` object after the specified delay. By using the `task_completion_event` class, you can define a task that completes after a thread or another task signals that a value is available. When the event is set, listener tasks complete and their continuations are scheduled to run.
 
@@ -19,7 +19,7 @@ The `cancel_after_timeout` function builds on the `complete_after` function to c
 
 [!code-cpp[concrt-task-delay#1](../../parallel/concrt/codesnippet/cpp/how-to-create-a-task-that-completes-after-a-delay_1.cpp)]
 
-## Example that computes the count of prime numbers
+## Example that computes count of prime numbers
 
 The following example computes the count of prime numbers in the range [0, 100000] multiple times. The operation fails if it does not complete in a given time limit. The `count_primes` function demonstrates how to use the `cancel_after_timeout` function. It counts the number of primes in the given range and fails if the task does not complete in the provided time. The `wmain` function calls the `count_primes` function multiple times. Each time, it halves the time limit. The program finishes after the operation does not complete in the current time limit.
 
diff --git a/docs/parallel/concrt/how-to-implement-various-producer-consumer-patterns.md b/docs/parallel/concrt/how-to-implement-various-producer-consumer-patterns.md
@@ -14,7 +14,7 @@ Both examples in this topic use agents, message blocks, and message-passing func
 
 For more information about asynchronous agents, see [Asynchronous Agents](../../parallel/concrt/asynchronous-agents.md). For more information about message blocks and message-passing functions, see [Asynchronous Message Blocks](../../parallel/concrt/asynchronous-message-blocks.md) and [Message Passing Functions](../../parallel/concrt/message-passing-functions.md).
 
-## Example sending a series of numbers to the consumer agent
+## Example sending series of numbers to consumer agent
 
 In this example, the producer agent sends a series of numbers to the consumer agent. The consumer receives each of these numbers and computes their average. The application writes the average to the console.
 
@@ -28,7 +28,7 @@ This example produces the following output.
 The average is 50.
 ```
 
-## Example sending a series of stock quotes to the consumer agent
+## Example sending series of stock quotes to consumer agent
 
 In this example, the producer agent sends a series of stock quotes to the consumer agent. The consumer agent periodically reads the current quote and prints it to the console.
 
diff --git a/docs/parallel/concrt/how-to-provide-work-functions-to-the-call-and-transformer-classes.md b/docs/parallel/concrt/how-to-provide-work-functions-to-the-call-and-transformer-classes.md
diff --git a/docs/parallel/concrt/how-to-use-alloc-and-free-to-improve-memory-performance.md b/docs/parallel/concrt/how-to-use-alloc-and-free-to-improve-memory-performance.md
