changed files by pdets auto publish service, publishid[9b3c92d9-f950-4cfb-8e6b-3c9597e3eefa] and do [publish].

Author: wwlpublish

learn-pr/wwl-language/create-manage-events/6-exercise-events-csharp.yml renamed to learn-pr/wwl-language/create-manage-events/6-exercise-implement-events-csharp.yml

@@ -1,5 +1,5 @@
 ### YamlMime:ModuleUnit
-uid: learn.wwl.create-manage-events.exercise-events-csharp
+uid: learn.wwl.create-manage-events.exercise-implement-events-csharp
 title: 'Exercise: Implement events in C#'
 metadata:
   title: 'Exercise: Implement events in C#'
@@ -10,4 +10,4 @@ metadata:
   ms.topic: unit
 durationInMinutes: 25
 content: |
-  [!include[](includes/6-exercise-events-csharp.md)]
+  [!include[](includes/6-exercise-implement-events-csharp.md)]

learn-pr/wwl-language/create-manage-events/includes/1-introduction.md

@@ -4,10 +4,10 @@ Imagine you're a developer working on a desktop application for a retail store.
 
 ## Learning objectives
 
-- Understand Events and Delegates in C#
-- Examine and Declare Events in C#
-- Encapsulate and Raise Events in C#
-- Manage Event Subscription and Unsubscription in C#
+- Understand Events and Delegates in C#.
+- Examine and Declare Events in C#.
+- Encapsulate and Raise Events in C#.
+- Manage Event Subscription and Unsubscription in C#.
 
 ## Prerequisites
 

learn-pr/wwl-language/create-manage-events/includes/2-examine-events-csharp.md

@@ -8,7 +8,7 @@ Events let one part of a program inform other parts when something important occ
 
 The following diagram illustrates the relationship between a publisher and subscribers in an event-driven model:
 
-![Publisher and Subscriber relationship](../media/PublisherSubscriber.png)
+:::image type="content" source="../media/publisher-subscriber.png" alt-text="Diagram showing publisher and subscriber relationship.":::
 
 - The **publisher** raises an event when a specific action occurs, such as the selection of a button.
 - The **subscribers** handle the event by executing their respective event handler methods.
@@ -51,7 +51,7 @@ Lambda expressions (`=>`) are used in the subscription to define the event handl
 
 Delegates are type-safe function pointers that allow methods to be passed as parameters and invoked dynamically. Events in C# are built on the foundation of delegates, which define the method signature for event handlers.
 
-**How delegates relate to events:**
+**How delegates relate to events**:
 
 - Delegates define the method signature that event handlers must match.
 - Events use delegates to notify subscribers when something significant occurs.
@@ -83,8 +83,8 @@ The design of events in C# aims to facilitate minimal coupling between component
 
 **Goals of event design**
 
-- **Minimal coupling:** Events enable interaction between an event source and an event sink without requiring tight dependencies. Minimal coupling, using events, is especially useful when components developed by different teams or updated independently.
-- **Ease of subscription and unsubscription:** The syntax for subscribing (`+=`) and unsubscribing (`-=`) is straightforward.
-- **Support for multiple subscribers:** Events can have zero, one, or multiple subscribers, making them versatile for various scenarios.
+- **Minimal coupling**: Events enable interaction between an event source and an event sink without requiring tight dependencies. Minimal coupling, using events, is especially useful when components developed by different teams or updated independently.
+- **Ease of subscription and unsubscription**: The syntax for subscribing (`+=`) and unsubscribing (`-=`) is straightforward.
+- **Support for multiple subscribers**: Events can have zero, one, or multiple subscribers, making them versatile for various scenarios.
 
 Events are often used in scenarios where user actions or system changes need to be communicated across components. For example, a `Closing` event might allow subscribers to cancel the close operation or modify its behavior.

learn-pr/wwl-language/create-manage-events/includes/3-declare-events-csharp.md

@@ -85,8 +85,8 @@ This example demonstrates how a derived class can override the base class's even
 
 ## Best practices for declaring events
 
-- **Encapsulation:** Use the `protected` access modifier for event-raising methods to ensure events are raised only within the declaring class or its derived classes.
-- **Virtual methods:** Use `protected virtual` methods to allow derived classes to customize event-raising logic.
-- **Event naming:** Use meaningful names for events to clearly indicate their purpose.
+- **Encapsulation**: Use the `protected` access modifier for event-raising methods to ensure events are raised only within the declaring class or its derived classes.
+- **Virtual methods**: Use `protected virtual` methods to allow derived classes to customize event-raising logic.
+- **Event naming**: Use meaningful names for events to clearly indicate their purpose.
 
 By understanding how to declare and use events in practical scenarios, you can build flexible and maintainable applications that respond effectively to user actions and system changes.

learn-pr/wwl-language/create-manage-events/includes/4-subscribe-unsubscribe-events-csharp.md

@@ -127,7 +127,7 @@ In this example, code contains dynamically managed event subscriptions. The `isS
 
 Memory leaks can occur when event handlers aren't unsubscribed, especially if the event publisher outlives the subscriber. To avoid memory leaks, always unsubscribe from events when they're no longer needed.
 
-**Best practices for avoiding memory leaks:**
+**Best practices for avoiding memory leaks**:
 
 - Use weak references or `WeakEventManager` in scenarios where the subscriber's lifetime is shorter than the publisher's.
 - Unsubscribe from events in the `Dispose` method of disposable objects.

learn-pr/wwl-language/create-manage-events/includes/5-explore-delegates-events-relationship-csharp.md

@@ -6,7 +6,7 @@ As you continue developing the retail store application, your team is now focuse
 
 Delegates are type-safe function pointers that allow methods to be passed as parameters and invoked dynamically. In other words, a delegate acts like a "contract" that specifies the method's signature, allowing you to pass methods around like variables. Events encapsulate delegates, providing a structured way to notify subscribers when something significant occurs. This unit explores how to use built-in delegates like `EventHandler` and `EventHandler<T>` to simplify event handling.
 
-### Using `EventHandler<T>` with Custom Event Data
+### Using `EventHandler<T>` with custom event data
 
 The `EventHandler<T>` delegate is a built-in delegate that simplifies event handling when custom event data needs to be passed to subscribers. It allows you to define event handlers that include additional information about the event.
 
@@ -62,7 +62,7 @@ In this example, the `OrderProcessed` event is declared as `EventHandler<OrderEv
 
 Lambda expressions, as shown in the subscription to the `OrderProcessed` event, are a standard way to concisely define event handlers inline.
 
-### Multicast Delegates
+### Multicast delegates
 
 Multicast delegates allow multiple methods to be invoked for a single event. Multicast delegates are useful when multiple subscribers need to respond to the same event, such as notifying different systems or components.
 
@@ -99,18 +99,23 @@ public class Program
 
 In this example, lambda expressions (`=>`) are used to define the event handlers for the `NotificationSent` event. Lambda expressions are frequently encountered with delegates and provide a concise and readable way to define event handlers, especially when the logic for each handler is straightforward.
 
-### Best Practices for Managing Events
+### Best practices for managing events
 
 Managing events effectively is critical for building robust and maintainable applications. Here are some best practices to follow:
 
-1. **Avoid Memory Leaks:**  
-   Always unsubscribe from events when they're no longer needed, especially if the event publisher has a longer lifetime than the subscriber.
+- **Avoid Memory Leaks**:  
 
-2. **Use Weak References:**  
-   In scenarios where the subscriber's lifetime is shorter than the publisher's, consider using weak references or the `WeakEventManager` to avoid memory leaks.
+  Always unsubscribe from events when they're no longer needed, especially if the event publisher has a longer lifetime than the subscriber.
 
-3. **Ensure Thread Safety:**  
-   If events are raised in a multithreaded environment, ensure thread safety by using synchronization mechanisms like locks or thread-safe collections.
+
+- **Use Weak References**:  
+
+  In scenarios where the subscriber's lifetime is shorter than the publisher's, consider using weak references or the `WeakEventManager` to avoid memory leaks.
+
+
+- **Ensure Thread Safety**:  
+
+  If events are raised in a multithreaded environment, ensure thread safety by using synchronization mechanisms like locks or thread-safe collections.
 
 **Example: Unsubscribing to avoid memory leaks**
 
@@ -132,7 +137,7 @@ public class Subscriber : IDisposable
 }
 ```
 
-### Summary
+## Summary
 
 In this unit, you explored advanced concepts of delegates and events in C#, including:
 

learn-pr/wwl-language/create-manage-events/includes/6-exercise-events-csharp.md renamed to learn-pr/wwl-language/create-manage-events/includes/6-exercise-implement-events-csharp.md

@@ -8,7 +8,7 @@ After completing this module, you're now able to:
 - Subscribe to and unsubscribe from events programmatically to manage resources effectively.  
 - Apply modern .NET Core practices for event handling, including the use of `EventHandler` and custom `EventArgs` classes.  
 
-Now that you have a basic understanding of events, consider reviewing the following resources.
+Now that you have a basic understanding of events, consider reviewing the following resources:
 
 - [Events (C# Programming Guide)](/dotnet/csharp/programming-guide/events/)  
 - [Delegates and Events in C#](/dotnet/csharp/programming-guide/delegates-and-events/)  

learn-pr/wwl-language/create-manage-events/includes/8-summary.md

@@ -1,7 +1,7 @@
 ### YamlMime:Module
 uid: learn.wwl.create-manage-events
 metadata:
-  title: Create and manage events
+  title: Create and Manage Events
   description: "Discover how events facilitate communication between objects in C#, and how their integration with delegates creates robust, decoupled code."
   ms.date: 04/23/2025
   author: wwlpublish
@@ -14,13 +14,13 @@ metadata:
 title: Create and manage events
 summary: Learn the fundamentals of events in C#, including their reliance on delegates and their role in enabling communication between objects.
 abstract: |
-  -   Understand Events and Delegates in C#
+  -   Understand Events and Delegates in C#.
 
-  -   Examine and Declare Events in C#
+  -   Examine and Declare Events in C#.
 
-  -   Encapsulate and Raise Events in C#
+  -   Encapsulate and Raise Events in C#.
 
-  -   Manage Event Subscription and Unsubscription in C#
+  -   Manage Event Subscription and Unsubscription in C#.
 prerequisites: |
   -   An installation of Visual Studio Code with the C# Dev Kit extension installed.
 
@@ -47,7 +47,7 @@ units:
 - learn.wwl.create-manage-events.declare-events-csharp
 - learn.wwl.create-manage-events.subscribe-unsubscribe-events-csharp
 - learn.wwl.create-manage-events.explore-delegates-events-relationship-csharp
-- learn.wwl.create-manage-events.exercise-events-csharp
+- learn.wwl.create-manage-events.exercise-implement-events-csharp
 - learn.wwl.create-manage-events.knowledge-check
 - learn.wwl.create-manage-events.summary
 badge: