Event unsubscription and memory in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this event subscription code?

Consider the following C# code where an event is subscribed and then triggered. What will be printed to the console?

C Sharp (C#)

using System;

class Publisher {
    public event Action OnChange;
    public void Raise() {
        OnChange?.Invoke();
    }
}

class Subscriber {
    public void Subscribe(Publisher p) {
        p.OnChange += () => Console.WriteLine("Event triggered");
    }
}

class Program {
    static void Main() {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber();
        sub.Subscribe(pub);
        pub.Raise();
    }
}

A Runtime exception

B Event triggered

C No output

D Compilation error

💡 Hint

Think about what happens when the event is raised after subscription.

The subscriber adds a handler to the event. When Raise() is called, the event triggers and prints "Event triggered".

❓ Predict Output

intermediate

What happens if you forget to unsubscribe from an event?

Given the code below, what will be the output after GC.Collect() is called?

C Sharp (C#)

using System;

class Publisher {
    public event Action OnChange;
    public void Raise() {
        OnChange?.Invoke();
    }
}

class Subscriber {
    public Subscriber(Publisher p) {
        p.OnChange += Handler;
    }
    void Handler() {
        Console.WriteLine("Handled event");
    }
    ~Subscriber() {
        Console.WriteLine("Subscriber finalized");
    }
}

class Program {
    static void Main() {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber(pub);
        sub = null;
        GC.Collect();
        GC.WaitForPendingFinalizers();
        pub.Raise();
    }
}

A No output

B

Subscriber finalized
Handled event

C

Handled event
Subscriber finalized

D Handled event

💡 Hint

Think about whether the subscriber object is collected by the garbage collector.

The subscriber is still referenced by the publisher's event delegate, so it is not garbage collected. The finalizer does not run, and the event handler runs printing "Handled event".

🔧 Debug

advanced

Why does this event unsubscription fail to prevent memory leaks?

Examine the code below. The developer tries to unsubscribe the event to avoid memory leaks but it doesn't work. Why?

C Sharp (C#)

using System;

class Publisher {
    public event Action OnChange;
    public void Raise() => OnChange?.Invoke();
}

class Subscriber {
    private Publisher _pub;
    public Subscriber(Publisher pub) {
        _pub = pub;
        _pub.OnChange += Handler;
    }
    public void Unsubscribe() {
        _pub.OnChange -= () => Console.WriteLine("Handled");
    }
    private void Handler() {
        Console.WriteLine("Handled");
    }
}

class Program {
    static void Main() {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber(pub);
        sub.Unsubscribe();
        pub.Raise();
    }
}

A The lambda used in Unsubscribe is a different delegate instance than the one subscribed, so unsubscription fails.

B The event is null so unsubscription throws an exception.

C The Handler method is private and cannot be unsubscribed.

D The Publisher class does not support unsubscription.

💡 Hint

Consider how delegates and lambdas work in C# when subscribing and unsubscribing.

Unsubscription requires the exact same delegate instance. The lambda in Unsubscribe() is a new delegate, so it does not remove the original subscription, causing the event to still fire.

❓ Predict Output

advanced

What is the output when using weak event pattern?

Consider this code using a weak event pattern to avoid memory leaks. What will be printed?

C Sharp (C#)

using System;
using System.Runtime.CompilerServices;

class Publisher {
    public event Action OnChange;
    public void Raise() => OnChange?.Invoke();
}

class Subscriber {
    public Subscriber(Publisher pub) {
        WeakReference<Subscriber> weakRef = new WeakReference<Subscriber>(this);
        pub.OnChange += () => {
            if (weakRef.TryGetTarget(out var target)) {
                target.Handler();
            }
        };
    }
    public void Handler() {
        Console.WriteLine("Handled via weak ref");
    }
    ~Subscriber() {
        Console.WriteLine("Subscriber finalized");
    }
}

class Program {
    static void Main() {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber(pub);
        sub = null;
        GC.Collect();
        GC.WaitForPendingFinalizers();
        pub.Raise();
    }
}

A Handled via weak ref

B

Subscriber finalized
Handled via weak ref

C

Subscriber finalized
No output from event

D No output

💡 Hint

Think about whether the subscriber is still alive when the event is raised.

The weak reference does not keep the subscriber alive. After GC, the subscriber is finalized and the event handler does not run because the target is gone.

🧠 Conceptual

expert

Which statement best explains event unsubscription's role in memory management?

Choose the best explanation for why unsubscribing from events is important to prevent memory leaks in C#.

A Event subscriptions create strong references from the publisher to the subscriber, preventing garbage collection unless unsubscribed.

B Unsubscribing events automatically frees all memory used by the subscriber immediately.

C Events use weak references by default, so unsubscription is only needed for performance reasons.

D Subscribers hold references to publishers, so unsubscribing breaks this link to avoid leaks.

💡 Hint

Consider how event delegates hold references internally.

When a subscriber subscribes to an event, the publisher holds a strong reference to the subscriber delegate, preventing the subscriber from being garbage collected until unsubscribed.