Explain the concept of weak references

Weak references allow you to maintain a reference to an object while still permitting the garbage collector to reclaim it if memory is needed.

How It Works:

// Strong reference prevents GC
MyClass strongRef = new MyClass();

// Weak reference allows GC
WeakReference weakRef = new WeakReference(new MyClass());

Use Cases:

1. Caching without preventing garbage collection:

public class ImageCache
{
    private Dictionary _cache = new();

    public Image GetImage(string path)
    {
        if (_cache.TryGetValue(path, out WeakReference weakRef))
        {
            if (weakRef.Target is Image image)
                return image; // Still alive
        }

        // Load image if not cached or was collected
        Image newImage = LoadImage(path);
        _cache[path] = new WeakReference(newImage);
        return newImage;
    }
}

1. Event handlers to prevent memory leaks:

public class WeakEventManager
{
    private List _subscribers = new();

    public void Subscribe(EventHandler handler)
    {
        _subscribers.Add(new WeakReference(handler));
    }

    public void RaiseEvent(object sender, EventArgs e)
    {
        _subscribers.RemoveAll(wr => !wr.IsAlive);
        
        foreach (var wr in _subscribers)
        {
            if (wr.Target is EventHandler handler)
                handler(sender, e);
        }
    }
}

Types of Weak References:

1. Short Weak Reference (default):

WeakReference wr = new WeakReference(target);
// Target can be collected, even before finalizer runs

1. Long Weak Reference:

WeakReference wr = new WeakReference(target, trackResurrection: true);
// Target accessible until after finalizer runs

Generic WeakReference<T>:

WeakReference weakRef = new WeakReference(obj);

if (weakRef.TryGetTarget(out MyClass target))
{
    // Object still alive, use it
    target.DoSomething();
}
else
{
    // Object was collected
}

Important Considerations:

• Check IsAlive or use TryGetTarget() before accessing target
• Target can be collected between checking and accessing
• Not thread-safe by default
• Adds slight overhead for GC tracking
• Best for large objects with expensive recreation costs

When to Use Weak References:

• Implementing caches that shouldn't prevent GC
• Managing event subscriptions
• Tracking objects without keeping them alive
• Building object pools with automatic cleanup