Event unsubscription and memory in C Sharp (C#) - Mini Project: Build & Apply

Event unsubscription and memory

📖 Scenario: Imagine you have a simple program where a Button can be clicked, and a Listener responds to the click event. If you don't unsubscribe the listener when it's no longer needed, it can cause memory problems.

🎯 Goal: You will create a Button class with a click event, a Listener class that subscribes to the event, then unsubscribe the listener to avoid memory leaks.

📋 What You'll Learn

Create a Button class with a Click event

Create a Listener class with a method to handle the click

Subscribe the listener to the button's click event

Unsubscribe the listener from the click event

Print messages to show when the event is handled and when unsubscribed

💡 Why This Matters

🌍 Real World

Events are used in user interfaces, games, and many applications to respond to user actions or system changes.

💼 Career

Understanding event subscription and unsubscription is important for writing efficient, memory-safe C# applications.

1

Create the Button class with a Click event

Create a class called Button with a public event Click of type EventHandler. Also add a method OnClick() that invokes the Click event if it is not null.

C Sharp (C#)

// Your code here

Hint

Use public event EventHandler? Click; and invoke it with Click?.Invoke(this, EventArgs.Empty);

2

Create the Listener class and subscribe to the Click event

Create a class called Listener with a method HandleClick that matches the EventHandler signature and prints "Button clicked!". Then create a Button instance called button and a Listener instance called listener. Subscribe listener.HandleClick to button.Click.

C Sharp (C#)

using System;

public class Button
{
    public event EventHandler? Click;

    public void OnClick()
    {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

// Your code here

Hint

Make sure HandleClick matches EventHandler signature and subscribe with button.Click += listener.HandleClick;

3

Unsubscribe the listener from the Click event

Add a line to unsubscribe listener.HandleClick from button.Click using -=. This should be after the subscription line.

C Sharp (C#)

using System;

public class Button
{
    public event EventHandler? Click;

    public void OnClick()
    {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

public class Listener
{
    public void HandleClick(object? sender, EventArgs e)
    {
        Console.WriteLine("Button clicked!");
    }
}

class Program
{
    static void Main()
    {
        Button button = new Button();
        Listener listener = new Listener();
        button.Click += listener.HandleClick;
        // Unsubscribe the listener here
    }
}

Hint

Use button.Click -= listener.HandleClick; to unsubscribe.

4

Test the event subscription and unsubscription

Call button.OnClick() twice: once before unsubscribing and once after unsubscribing. Print "Clicked once" before the first call and "Clicked twice" before the second call to show the difference.

C Sharp (C#)

using System;

public class Button
{
    public event EventHandler? Click;

    public void OnClick()
    {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

public class Listener
{
    public void HandleClick(object? sender, EventArgs e)
    {
        Console.WriteLine("Button clicked!");
    }
}

class Program
{
    static void Main()
    {
        Button button = new Button();
        Listener listener = new Listener();
        button.Click += listener.HandleClick;
        button.Click -= listener.HandleClick;
        // Call OnClick and print messages
    }
}

Hint

Print messages before each OnClick() call to show when the event handler runs.

Practice

1. What happens if you do not unsubscribe from an event in C#?

easy

A. The event will automatically unsubscribe after the first call.

B. The program will throw a compile-time error.

C. The subscriber object may not be garbage collected, causing a memory leak.

D. The event handler will be called only once.

Solution

1. Step 1: Understand event subscription behavior

   When an object subscribes to an event, the event publisher holds a reference to the subscriber's method.

2. Step 2: Effect of not unsubscribing

   If you don't unsubscribe, the subscriber object remains referenced and cannot be garbage collected, causing a memory leak.

3. Final Answer:

   The subscriber object may not be garbage collected, causing a memory leak. -> Option C

4. Quick Check:

   Not unsubscribing = memory leak [OK]

Hint: Always unsubscribe to avoid memory leaks and keep memory clean [OK]

Common Mistakes:

• Assuming events auto-unsubscribe
• Thinking unsubscribing causes errors
• Believing event handlers run only once

2. Which syntax correctly unsubscribes a method named OnDataReceived from an event DataReceived?

easy

A. DataReceived -= OnDataReceived;

B. DataReceived += OnDataReceived;

C. DataReceived = null;

D. DataReceived.Unsubscribe(OnDataReceived);

Solution

1. Step 1: Recall event unsubscription syntax

   In C#, to unsubscribe from an event, use the '-=' operator with the same method.

2. Step 2: Match correct syntax

   DataReceived -= OnDataReceived; uses 'DataReceived -= OnDataReceived;', which is the correct way to unsubscribe.

3. Final Answer:

   DataReceived -= OnDataReceived; -> Option A

4. Quick Check:

   Unsubscribe syntax = '-=' operator [OK]

Hint: Use '-=' with the same method to unsubscribe events [OK]

Common Mistakes:

• Using '+=' instead of '-=' to unsubscribe
• Trying to assign null to the event
• Using non-existent Unsubscribe method

3. What will be the output of the following code?

using System;
class Program {
  static event Action MyEvent;
  static void Handler() => Console.WriteLine("Called");
  static void Main() {
    MyEvent += Handler;
    MyEvent -= Handler;
    MyEvent?.Invoke();
  }
}

medium

A. Called

B. No output

C. NullReferenceException

D. Compile-time error

Solution

1. Step 1: Analyze event subscription and unsubscription

   The method Handler is subscribed then immediately unsubscribed from MyEvent.

2. Step 2: Check event invocation

   Since no handlers remain, MyEvent is null, so MyEvent?.Invoke() does nothing and prints no output.

3. Final Answer:

   No output -> Option B

4. Quick Check:

   Unsubscribed event = no call [OK]

Hint: Unsubscribed event handlers do not run when invoked [OK]

Common Mistakes:

• Expecting output despite unsubscription
• Ignoring null conditional operator
• Thinking event throws exception if empty

4. Identify the problem in this code snippet related to event unsubscription:

class Publisher {
  public event Action OnChange;
  public void Raise() => OnChange?.Invoke();
}
class Subscriber {
  public void Subscribe(Publisher p) {
    p.OnChange += HandleChange;
  }
  void HandleChange() {
    Console.WriteLine("Changed");
  }
}

medium

A. Subscriber never unsubscribes, causing potential memory leaks.

B. Event is invoked incorrectly with null conditional operator.

C. Handler method signature does not match event delegate.

D. Publisher event is not declared as static.

Solution

1. Step 1: Review subscription and unsubscription

   The Subscriber subscribes to the event but never unsubscribes.

2. Step 2: Understand consequences

   Without unsubscription, the Subscriber object remains referenced by Publisher, causing memory leaks.

3. Final Answer:

   Subscriber never unsubscribes, causing potential memory leaks. -> Option A

4. Quick Check:

   Missing unsubscribe = memory leak risk [OK]

Hint: Always unsubscribe to avoid memory leaks in event handlers [OK]

Common Mistakes:

• Ignoring unsubscription importance
• Confusing static and instance events
• Assuming null conditional operator causes errors

5. You have a long-running application where multiple subscribers attach to a static event but never unsubscribe. What is the best approach to prevent memory leaks?

hard

A. Replace events with polling loops to avoid subscription issues.

B. Make the event instance-level instead of static to avoid leaks.

C. Ignore unsubscription because garbage collector handles it automatically.

D. Use weak event patterns or explicitly unsubscribe when subscribers are no longer needed.

Solution

1. Step 1: Understand static event references

   Static events hold references for the app lifetime, so subscribers never get garbage collected unless unsubscribed.

2. Step 2: Best practice to avoid leaks

   Using weak event patterns or explicitly unsubscribing prevents memory leaks by releasing subscriber references.

3. Final Answer:

   Use weak event patterns or explicitly unsubscribe when subscribers are no longer needed. -> Option D

4. Quick Check:

   Weak events or unsubscribe = prevent leaks [OK]

Hint: Use weak events or unsubscribe explicitly to avoid leaks [OK]

Common Mistakes:

• Assuming GC cleans static event subscribers
• Changing event to instance-level without reason
• Replacing events with inefficient polling