The Problem

I am seeing lots of memory leaks rooting to events in application development. The fix for these issues is not small and sometimes the code changes are big and complex.
(one of many examples dotnet/maui#36274)

What if we could have a WeakDelegate? A weakly referenced delegate would solve this pain point entirely. When a short-lived object subscribes to an event on a long-lived object, it shouldn't stop the garbage collector from collecting the referencee.

Proposed Solution

Introduce a new type in the .NET core runtime called WeakDelegate.

Type Specification

• Type name: System.WeakDelegate
• The main difference from a normal Delegate is that the reference to the target object should be a weak reference.
• It must not prevent the Garbage Collector from collecting the object instance it points to.
• Checking if the delegate is assigned should not change. Developers should be able to check for null exactly as they do today, and that should work perfectly.

Proposed C# Syntax Options

We can approach this in two ways:

Option 1: The delegate? operator

public delegate? void MyEvent();

• No new keywords are introduced to the language.
• It is easy for developers to understand based on existing nullability patterns.

Option 2: The weakdelegate keyword

public weakdelegate void MyEvent();

• Gives a clear definition of the exact intent of the developer.
• Explicitly states that the reference chain is weak, though it requires a new keyword.

Prior Implementation

There was already a type named WeakDelegate implemented in the .NET Micro Framework. Since that framework is discontinued and the implementation was a specialized workaround for small embedded systems, this proposal seeks a first-class integration into the modern .NET core runtime.