We use weak events in C# to avoid memory leaks in event-based applications. Let’s learn more about weak events, why they’re needed, and how to implement them.<\/p>\n
Let’s get started.<\/p>\n
A strong event<\/a> is the default implementation of an event in C#. It enables an object to notify other objects when a change occurs.\u00a0<\/p>\n Let’s see it in action by creating a Now, let’s create a When subscribing to the event, we create a strong reference between the publisher and the subscriber. This strong reference doesn’t allow the garbage collector (GC)<\/a> to collect the subscriber object as the publisher is still alive (i.e. GC hasn’t collected it).\u00a0<\/strong><\/p>\n On the other hand, when creating a weak event, the event handler creates a weak reference between the publisher and the subscriber. A weak reference allows the GC to collect the object if there are no other strong references to it.<\/strong><\/p>\n When we raise an event, the weak reference is checked to see if the target (subscriber) is still alive. If it is, the application invokes the event handler. However, if the target has been collected, the weak reference is removed from the list of event handlers.<\/p>\n To understand why we need weak events, we need to review our default implementation of an event.<\/p>\n Let’s imagine a data provider service that raises periodic events to update a part of the application UI. The When these UI components subscribe to the service\u2019s events, the service holds a strong reference to the event handlers in each UI component. If we assume a user can remove these UI components on demand, we’d expect the GC to free up the memory when these components are no longer needed.<\/p>\n However, due to the strong references held by the service, the GC can’t reclaim the memory used by these UI components. This leads to a memory leak:<\/p>\n Here, we’ve explicitly set the When we run the application, it raises the event even after the garbage collection process:<\/p>\n By using weak references instead, we ensure that the event subscription does not prevent the garbage collection of the subscriber.<\/strong> Thus, weak events help manage memory more efficiently by ensuring that objects are collected as soon as they are no longer needed.<\/p>\n We can use the Let’s create a The _eventHandlers<\/span><\/span> field maintains a list of weak references to event handlers. It allows subscribers to subscribe to events raised by publishers without creating strong references between them:<\/p>\n Next, let’s add an And another Finally, let’s add aPublisher<\/code> class:<\/p>\npublic class Publisher\r\n{\r\n public event EventHandler? Event;\r\n\r\n public void RaiseEvent()\r\n {\r\n Event?.Invoke(this, EventArgs.Empty);\r\n }\r\n}<\/pre>\nSubscriber<\/code> class to subscribe to the Event<\/code>\u00a0event:<\/p>\npublic class Subscriber\r\n{\r\n public void HandleEvent(object sender, EventArgs e)\r\n {\r\n Console.WriteLine(\"Event received.\");\r\n }\r\n}<\/pre>\n<\/a>Why Do We Need Weak Events?<\/h2>\n
Publisher<\/code> class could represent this service while the Subscriber<\/code> class would represent the UI components.<\/p>\nvar publisher = new Publisher();\r\nvar subscriber = new Subscriber();\r\n\r\npublisher.Event += subscriber.HandleEvent;\r\npublisher.RaiseEvent();\r\nsubscriber = null;\r\n\r\nGC.Collect();\r\n\r\npublisher.RaiseEvent();<\/pre>\n
subscriber<\/code> object to null<\/code> to simulate a component removal. Then, we force garbage collection using the GC.Collect()<\/code> method. However, it’s still not eligible for garbage collection as publisher<\/code> holds a strong reference to it.<\/p>\nEvent received.\r\nEvent received.<\/pre>\n
<\/a>How to Implement Weak Events<\/h2>\n
WeakReference<\/code> class to implement a weak event mechanism. The WeakReference<\/code> class holds a weak reference to an object. This ensures that the application doesn’t prevent the garbage collector from collecting the object if there are no other strong references to it.<\/p>\nWeakEvent<\/code> class:<\/p>\npublic class WeakEvent<TEventArgs> where TEventArgs : EventArgs\r\n{\r\n private readonly List<WeakReference<EventHandler<TEventArgs>>> _eventHandlers = [];\r\n}<\/pre>\nAddEventHandler()<\/code> method to add event handlers in this class:<\/p>\npublic void AddEventHandler(EventHandler<TEventArgs> handler)\r\n{\r\n if (handler == null) return;\r\n\r\n _eventHandlers.Add(new WeakReference<EventHandler<TEventArgs>>(handler));\r\n}<\/pre>\nRemoveEventHandler()<\/code> method to remove event handlers:<\/p>\npublic void RemoveEventHandler(EventHandler<TEventArgs> handler)\r\n{\r\n var eventHandler = _eventHandlers.FirstOrDefault(wr =>\r\n {\r\n wr.TryGetTarget(out var target);\r\n\r\n return target == handler;\r\n });\r\n\r\n if (eventHandler != null)\r\n {\r\n _eventHandlers.Remove(eventHandler);\r\n }\r\n}<\/pre>\nRaiseEvent()<\/code> method:<\/p>\npublic void RaiseEvent(object sender, TEventArgs e)\r\n{\r\n foreach (var eventHandler in _eventHandlers.ToArray())\r\n {\r\n if (eventHandler.TryGetTarget(out var handler))\r\n {\r\n handler(sender, e);\r\n }\r\n }\r\n}<\/pre>\n