Merge pull request #3296 from corob-msft/docs/corob/cpp-docs-2609

Update to address 2609 event handling /permissive- compat

Author: ttorble

docs/cpp/event-handling-in-com.md

@@ -1,33 +1,36 @@
 ---
-title: "Event Handling in COM"
-ms.date: "11/04/2016"
+title: "Event handling in COM"
+description: "Learn how to use the Microsoft C++ extensions for COM event handling."
+ms.date: 11/20/2020
 helpviewer_keywords: ["event handling [C++], COM", "event handling [C++], about event handling", "declaring events", "event handlers [C++], COM", "event handlers", "COM, events", "event receivers, in event handling", "event handling [C++]", "hooking events", "event receivers, name and signature matching", "event sources, in event handling", "declaring events, in COM", "declaring events, event handling in COM"]
-ms.assetid: 6b4617d4-a58e-440c-a8a6-1ad1c715b2bb
 ---
-# Event Handling in COM
+# Event handling in COM
 
-In COM event handling, you set up an event source and event receiver using the [event_source](../windows/attributes/event-source.md) and [event_receiver](../windows/attributes/event-receiver.md) attributes, respectively, specifying `type`=`com`. These attributes inject the appropriate code for custom, dispatch, and dual interfaces to allow the classes to which they are applied to fire events and handle events through COM connection points.
+In COM event handling, you set up an event source and event receiver using the [`event_source`](../windows/attributes/event-source.md) and [`event_receiver`](../windows/attributes/event-receiver.md) attributes, respectively, specifying `type`=`com`. These attributes inject appropriate code for custom, dispatch, and dual interfaces. The injected code allows the attributed classes to fire events and handle events through COM connection points.
 
-## Declaring Events
+> [!NOTE]
+> Event attributes in native C++ are incompatible with Standard C++. They don't compile when you specify [`/permissive-`](../build/reference/permissive-standards-conformance.md) conformance mode.
+
+## Declaring events
 
-In an event source class, use the [__event](../cpp/event.md) keyword on an interface declaration to declare that interface's methods as events. The events of that interface are fired when you call them as interface methods. Methods on event interfaces can have zero or more parameters (which should all be *in* parameters). The return type can be void or any integral type.
+In an event source class, use the [`__event`](../cpp/event.md) keyword on an interface declaration to declare that interface's methods as events. The events of that interface are fired when you call them as interface methods. Methods on event interfaces can have zero or more parameters (which should all be *in* parameters). The return type can be void or any integral type.
 
-## Defining Event Handlers
+## Defining event handlers
 
-In an event receiver class, you define event handlers, which are methods with signatures (return types, calling conventions, and arguments) that match the event that they will handle. For COM events, calling conventions do not have to match; see [Layout Dependent COM Events](#vcconeventhandlingincomanchorlayoutdependentcomevents) below for details.
+You define event handlers in an event receiver class. Event handlers are methods with signatures (return types, calling conventions, and arguments) that match the event that they'll handle. For COM events, calling conventions don't have to match. For more information, see [Layout-dependent COM events](#vcconeventhandlingincomanchorlayoutdependentcomevents) below.
 
-## Hooking Event Handlers to Events
+## Hooking event handlers to events
 
-Also in an event receiver class, you use the intrinsic function [__hook](../cpp/hook.md) to associate events with event handlers and [__unhook](../cpp/unhook.md) to dissociate events from event handlers. You can hook several events to an event handler, or several event handlers to an event.
+Also in an event receiver class, you use the intrinsic function [`__hook`](../cpp/hook.md) to associate events with event handlers and [`__unhook`](../cpp/unhook.md) to disassociate events from event handlers. You can hook several events to an event handler, or several event handlers to an event.
 
 > [!NOTE]
 > Typically, there are two techniques to allow a COM event receiver to access event source interface definitions. The first, as shown below, is to share a common header file. The second is to use [#import](../preprocessor/hash-import-directive-cpp.md) with the `embedded_idl` import qualifier, so that the event source type library is written to the .tlh file with the attribute-generated code preserved.
 
-## Firing Events
+## Firing events
 
-To fire an event, simply call a method in the interface declared with the **`__event`** keyword in the event source class. If handlers have been hooked to the event, the handlers will be called.
+To fire an event, call a method in the interface declared with the **`__event`** keyword in the event source class. If handlers have been hooked to the event, the handlers will be called.
 
-### COM Event Code
+### COM event code
 
 The following example shows how to fire an event in a COM class. To compile and run the example, refer to the comments in the code.
 
@@ -138,13 +141,13 @@ MyHandler1 was called with value 123.
 MyHandler2 was called with value 123.
 ```
 
-## <a name="vcconeventhandlingincomanchorlayoutdependentcomevents"></a> Layout Dependent COM Events
+## <a name="vcconeventhandlingincomanchorlayoutdependentcomevents"></a> Layout-dependent COM events
 
-Layout dependency is only an issue for COM programming. In native and managed event handling, the signatures (return type, calling convention, and arguments) of the handlers must match their events, but the handler names do not have to match their events.
+Layout dependency is only an issue for COM programming. In native and managed event handling, the signatures (return type, calling convention, and arguments) of the handlers must match their events, but the handler names don't have to match their events.
 
-However, in COM event handling, when you set the *layout_dependent* parameter of `event_receiver` to **`true`**, the name and signature matching is enforced. This means that the names and signatures of the handlers in the event receiver must exactly match the names and signatures of the events to which they are hooked.
+However, in COM event handling, when you set the *`layout_dependent`* parameter of `event_receiver` to **`true`**, the name and signature matching is enforced. The names and signatures of the handlers in the event receiver and in the hooked events must exactly match.
 
-When *layout_dependent* is set to **`false`**, the calling convention and storage class (virtual, static, and so on) can be mixed and matched between the firing event method and the hooking methods (its delegates). It is slightly more efficient to have *layout_dependent*=**`true`**.
+When *`layout_dependent`* is set to **`false`**, the calling convention and storage class (virtual, static, and so on) can be mixed and matched between the firing event method and the hooking methods (its delegates). It's slightly more efficient to have *`layout_dependent`*=**`true`**.
 
 For example, suppose `IEventSource` is defined to have the following methods:
 
@@ -196,4 +199,4 @@ public:
 
 ## See also
 
-[Event Handling](../cpp/event-handling.md)
+[Event handling](../cpp/event-handling.md)

docs/cpp/event-handling-in-native-cpp.md

@@ -1,39 +1,43 @@
 ---
-title: "Event Handling in Native C++"
-ms.date: "05/07/2019"
+title: "Event handling in native C++"
+description: "Learn how to use the Microsoft C++ extensions for native C++ event handling."
+ms.date: 11/20/2020
 helpviewer_keywords: ["event handling [C++]"]
-ms.assetid: e4b9219a-15d8-42fb-83c8-6d2e4e087c8d
 ---
-# Event Handling in Native C++
+# Event handling in native C++
 
-In native C++ event handling, you set up an event source and event receiver using the [event_source](../windows/attributes/event-source.md) and [event_receiver](../windows/attributes/event-receiver.md) attributes, respectively, specifying `type`=`native`. These attributes allow the classes to which they are applied to fire events and handle events in a native, non-COM context.
+In native C++ event handling, you set up an event source and event receiver using the [event_source](../windows/attributes/event-source.md) and [event_receiver](../windows/attributes/event-receiver.md) attributes, respectively, specifying `type`=`native`. These attributes allow the classes they're applied on to fire events and handle events in a native, non-COM context.
 
-## Declaring Events
+> [!NOTE]
+> Event attributes in native C++ are incompatible with Standard C++. They don't compile when you specify [`/permissive-`](../build/reference/permissive-standards-conformance.md) conformance mode.
 
-In an event source class, use the [__event](../cpp/event.md) keyword on a method declaration to declare the method as an event. Make sure to declare the method, but do not define it; to do so will generate a compiler error, because the compiler defines the method implicitly when it is made into an event. Native events can be methods with zero or more parameters. The return type can be void or any integral type.
+## Declaring events
 
-## Defining Event Handlers
+In an event source class, use the [`__event`](../cpp/event.md) keyword on a method declaration to declare the method as an event. Make sure to declare the method, but don't define it. If you do, it generates a compiler error, because the compiler defines the method implicitly when it's made into an event. Native events can be methods with zero or more parameters. The return type can be **`void`** or any integral type.
 
-In an event receiver class, you define event handlers, which are methods with signatures (return types, calling conventions, and arguments) that match the event that they will handle.
+## Defining event handlers
 
-## Hooking Event Handlers to Events
+In an event receiver class, you define event handlers. Event handlers are methods with signatures (return types, calling conventions, and arguments) that match the event that they'll handle.
 
-Also in an event receiver class, you use the intrinsic function [__hook](../cpp/hook.md) to associate events with event handlers and [__unhook](../cpp/unhook.md) to dissociate events from event handlers. You can hook several events to an event handler, or several event handlers to an event.
+## Hooking event handlers to events
 
-## Firing Events
+Also in an event receiver class, you use the intrinsic function [`__hook`](../cpp/hook.md) to associate events with event handlers and [`__unhook`](../cpp/unhook.md) to disassociate events from event handlers. You can hook several events to an event handler, or several event handlers to an event.
 
-To fire an event, simply call the method declared as an event in the event source class. If handlers have been hooked to the event, the handlers will be called.
+## Firing events
 
-### Native C++ Event Code
+To fire an event, call the method declared as an event in the event source class. If handlers have been hooked to the event, the handlers will be called.
 
-The following example shows how to fire an event in native C++. To compile and run the example, refer to the comments in the code.
+### Native C++ event code
+
+The following example shows how to fire an event in native C++. To compile and run the example, refer to the comments in the code. To build the code in the Visual Studio IDE, verify that the **`/permissive-`** option is turned off.
 
 ## Example
 
 ### Code
 
 ```cpp
 // evh_native.cpp
+// compile by using: cl /EHsc /W3 evh_native.cpp
 #include <stdio.h>
 
 [event_source(native)]
@@ -83,4 +87,4 @@ MyHandler1 was called with value 123.
 
 ## See also
 
-[Event Handling](../cpp/event-handling.md)
+[Event handling](../cpp/event-handling.md)

docs/cpp/event-handling.md

@@ -1,29 +1,32 @@
 ---
-title: "Event Handling"
-ms.date: "05/07/2019"
+title: "Event handling"
+description: "Learn how Microsoft C++ extensions support both COM and native event handling."
+ms.date: 11/20/2020
 helpviewer_keywords: ["event handling [C++]"]
-ms.assetid: 82de3f9a-2d88-470c-9527-8a5b54c8ced4
 ---
-# Event Handling
+# Event handling
 
-Event handling is primarily supported for COM classes (C++ classes that implement COM objects, typically using ATL classes or the [coclass](../windows/attributes/coclass.md) attribute). For more information, see [Event Handling in COM](../cpp/event-handling-in-com.md).
+Event handling is primarily supported for COM classes (C++ classes that implement COM objects, typically using ATL classes or the [coclass](../windows/attributes/coclass.md) attribute). For more information, see [Event handling in COM](../cpp/event-handling-in-com.md).
 
-Event handling is also supported for native C++ classes (C++ classes that do not implement COM objects), however, that support is deprecated and will be removed in a future release.  For more information, see [Event Handling in Native C++](../cpp/event-handling-in-native-cpp.md).
+Event handling is also supported for native C++ classes (C++ classes that don't implement COM objects). Native C++ event handling support is deprecated and will be removed in a future release. For more information, see [Event handling in native C++](../cpp/event-handling-in-native-cpp.md).
 
-Event handling supports single- and multithreaded usage and protects data from simultaneous multithread access. It also allows you to derive subclasses from event source or receiver classes and support extended event sourcing/receiving in the derived class.
+> [!NOTE]
+> Event attributes in native C++ are incompatible with Standard C++. They don't compile when you specify [`/permissive-`](../build/reference/permissive-standards-conformance.md) conformance mode.
+
+Event handling supports both single- and multithreaded usage. It protects data from simultaneous multithread access. You can derive subclasses from event source or receiver classes. These subclasses support extended event sourcing and receiving.
 
 The Microsoft C++ compiler includes attributes and keywords for declaring events and event handlers. The event attributes and keywords can be used in CLR programs and in native C++ programs.
 
-|Topic|Description|
-|-----------|-----------------|
-|[event_source](../windows/attributes/event-source.md)|Creates an event source.|
-|[event_receiver](../windows/attributes/event-receiver.md)|Creates an event receiver (sink).|
-|[__event](../cpp/event.md)|Declares an event.|
-|[__raise](../cpp/raise.md)|Emphasizes the call site of an event.|
-|[__hook](../cpp/hook.md)|Associates a handler method with an event.|
-|[__unhook](../cpp/unhook.md)|Dissociates a handler method from an event.|
+| Article | Description |
+|--|--|
+| [`event_source`](../windows/attributes/event-source.md) | Creates an event source. |
+| [`event_receiver`](../windows/attributes/event-receiver.md) | Creates an event receiver (sink). |
+| [`__event`](../cpp/event.md) | Declares an event. |
+| [`__raise`](../cpp/raise.md) | Emphasizes the call site of an event. |
+| [`__hook`](../cpp/hook.md) | Associates a handler method with an event. |
+| [`__unhook`](../cpp/unhook.md) | Disassociates a handler method from an event. |
 
 ## See also
 
-[C++ Language Reference](../cpp/cpp-language-reference.md)<br/>
+[C++ language reference](../cpp/cpp-language-reference.md)\
 [Keywords](../cpp/keywords-cpp.md)