1769497, incorporated author review feedback.

john-par · john-par · commit 6aa93e2fc864 · 2020-09-25T09:18:56.000-07:00
diff --git a/docs/cpp/how-to-create-and-use-ccomptr-and-ccomqiptr-instances.md b/docs/cpp/how-to-create-and-use-ccomptr-and-ccomqiptr-instances.md
@@ -11,21 +11,21 @@ In classic Windows programming, libraries are often implemented as COM objects (
 
 When you instantiate a Component Object Model (COM) object, store the interface pointer in a COM smart pointer, which performs the reference counting by using calls to `AddRef` and `Release` in the destructor. If you are using the Active Template Library (ATL) or the Microsoft Foundation Class Library (MFC), then use the `CComPtr` smart pointer. If you are not using ATL or MFC, then use `_com_ptr_t`. Because there is no COM equivalent to `std::unique_ptr`, use these smart pointers for both single-owner and multiple-owner scenarios. Both `CComPtr` and `ComQIPtr` support move operations that have rvalue references.
 
-## Example using CComPtr
+## Example: CComPtr
 
 The following example shows how to use `CComPtr` to instantiate a COM object and obtain pointers to its interfaces. Notice that the `CComPtr::CoCreateInstance` member function is used to create the COM object, instead of the Win32 function that has the same name.
 
 [!code-cpp[COM_smart_pointers#01](../cpp/codesnippet/CPP/how-to-create-and-use-ccomptr-and-ccomqiptr-instances_1.cpp)]
 
 `CComPtr` and its relatives are part of the ATL and are defined in \<atlcomcli.h>. `_com_ptr_t` is declared in \<comip.h>. The compiler creates specializations of `_com_ptr_t` when it generates wrapper classes for type libraries.
 
-## Example using CComQIPt
+## Example: CComQIPt
 
 ATL also provides `CComQIPtr`, which has a simpler syntax for querying a COM object to retrieve an additional interface. However, we recommend `CComPtr` because it does everything that `CComQIPtr` can do and is semantically more consistent with raw COM interface pointers. If you use a `CComPtr` to query for an interface, the new interface pointer is placed in an out parameter. If the call fails, an HRESULT is returned, which is the typical COM pattern. With `CComQIPtr`, the return value is the pointer itself, and if the call fails, the internal HRESULT return value cannot be accessed. The following two lines show how the error handling mechanisms in `CComPtr` and `CComQIPtr` differ.
 
 [!code-cpp[COM_smart_pointers#02](../cpp/codesnippet/CPP/how-to-create-and-use-ccomptr-and-ccomqiptr-instances_2.cpp)]
 
-## Example using IDispatch
+## Example: IDispatch
 
 `CComPtr` provides a specialization for IDispatch that enables it to store pointers to COM automation components and invoke the methods on the interface by using late binding. `CComDispatchDriver` is a typedef for `CComQIPtr<IDispatch, &IIDIDispatch>`, which is implicitly convertible to `CComPtr<IDispatch>`. Therefore, when any of these three names appears in code, it is equivalent to `CComPtr<IDispatch>`. The following example shows how to obtain a pointer to the Microsoft Word object model by using a `CComPtr<IDispatch>`.
 
diff --git a/docs/dotnet/debug-class-cpp-cli.md b/docs/dotnet/debug-class-cpp-cli.md
@@ -12,7 +12,7 @@ When using <xref:System.Diagnostics.Debug> in a Visual C++ application, the beha
 
 The behavior for <xref:System.Diagnostics.Trace> is identical to the behavior for the Debug class, but is dependent on the symbol TRACE being defined. This means that you must `#ifdef` any Trace-related code to prevent debug behavior in a release build.
 
-## Example that always executes output statements
+## Example: Always executes output statements
 
 ### Description
 
@@ -49,7 +49,7 @@ Hello World.
 test
 ```
 
-## Example using #ifdef and #endif directives
+## Example: Use #ifdef and #endif directives
 
 ### Description
 
diff --git a/docs/dotnet/double-thunking-cpp.md b/docs/dotnet/double-thunking-cpp.md
@@ -18,7 +18,7 @@ Similarly, if you export ([dllexport, dllimport](../cpp/dllexport-dllimport.md))
 
 The compiler has been updated to reduce unnecessary double thunking. For example, any function with a managed type in the signature (including return type) will implicitly be marked as `__clrcall`.
 
-## Example of double thunking
+## Example: Double thunking
 
 ### Description
 
@@ -76,7 +76,7 @@ after calling struct S
 __thiscall T::~T(void)
 ```
 
-## Example of the effect of double thunking
+## Example: Effect of double thunking
 
 ### Description
 
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
@@ -11,7 +11,7 @@ ms.assetid: d0551836-9ac7-41eb-a6e9-a4b3ef60767d
 > [!NOTE]
 > The ISO C++11 Standard language has the [override](../cpp/override-specifier.md) identifier and the [final](../cpp/final-specifier.md) identifier, and both are supported in Visual Studio  Use `final` instead of **`sealed`** in code that is meant to be compiled as native-only.
 
-## Example showing sealed is valid
+## Example: sealed is valid
 
 ### Description
 
@@ -40,7 +40,7 @@ public:
 };
 ```
 
-## Example showing override is valid
+## Example: override is valid
 
 ### Description
 
@@ -62,7 +62,7 @@ public:
 };
 ```
 
-## Example showing abstract is valid
+## Example: 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 marshaling library
+## Example: Extend 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 employee information
+## Example: Convert 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 ANSI string
+## Example; Pass 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 ANSI string
+## Example: 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 managed array to unmanaged function
+## Example: Pass 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 unmanaged array to managed function
+## Example: Pass 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 unmanaged API to trigger managed delegate
+## Example: Configure 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 function pointer stored by unmanaged API
+## Example: 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 BSTR from managed to unmanaged function
+## Example: Pass 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 BSTR from unmanaged to managed function
+## Example: Pass BSTR from unmanaged to unmanaged 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 structure from managed to unmanaged function
+## Example: Pass 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 structure from unmanaged to managed function
+## Example: Pass 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 Unicode string from managed to unmanaged function
+## Example: Pass 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 Unicode string
+## Example: 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 generic class defined in C#
+## Example: Generic class defined in C#
 
 ### Description
 
@@ -73,7 +73,7 @@ public class CircularList<ItemType> {
 }
 ```
 
-## Example consumes assembly authored in C#
+## Example: Consume assembly authored in C#
 
 ### Description
 
diff --git a/docs/extensions/generic-classes-cpp-cli.md b/docs/extensions/generic-classes-cpp-cli.md
@@ -147,7 +147,7 @@ This section demonstrates the use of instance and static fields in generic class
 
 Instance variables of a generic class can have types and variable initializers that include any type parameters from the enclosing class.
 
-## Example of different generic classes
+## Example: Different generic classes
 
 In the following example, three different instances of the generic class, MyClass\<ItemType>, are created by using the appropriate type arguments (**`int`**, **`double`**, and **string**).
 
@@ -195,7 +195,7 @@ On the creation of a new generic type, new instances of any static variables are
 
 Static variables can use any type parameters from the enclosing class.
 
-## Example using static variables
+## Example: Use static variables
 
 The following example demonstrates using static fields and a static constructor within a generic class.
 
@@ -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 non-generic method
+## Example: Declare 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.
 
@@ -333,7 +333,7 @@ Amount: $123.00**
 
 You can declare generic methods in both generic and non-generic classes. For example:
 
-## Example declaring generic and non-generic methods
+## Example: Declare generic and non-generic methods
 
 ```cpp
 // generics_method2.cpp
@@ -359,7 +359,7 @@ The non-generic method is still generic in the sense that it is parameterized by
 
 All types of methods in generic classes can be generic, including static, instance, and virtual methods.
 
-## Example declaring and using generic methods
+## Example: Declare and using generic methods
 
 The following example demonstrates declaring and using generic methods within generic classes:
 
@@ -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 linked list
+## Example: Build and read 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 instance property
+## Example: Declare instance property
 
 This example shows declarations of an instance property within a generic class.
 
@@ -586,7 +586,7 @@ int main() {
 John, 234
 ```
 
-## Example of generic class with event
+## Example: 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 generic struct
+## Example: Declare 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
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
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
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
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
