When to Use

Short answer: rarely. Most applications won’t require this.

Long answer: If all of the following criteria are met, then you may want to consider it:

1. Memory use needs to be tightly restricted – this probably means mobile devices these days. If you’re running on Windows RT or Windows Phone, then your memory is restricted.
2. Object lifetime is highly variable – if you can predict the lifetime of your objects well, then using WeakReference doesn’t really make sense. In that case, you should just control their lifetime directly.
3. Objects are relatively large, but easy to create – WeakReference is really ideal for that large object that would be nice to have around, but if not, you could easily regenerate it as needed (or just do without).
4. The object’s size is significantly more than the overhead of using WeakReference<T> – Using WeakReference<T> adds an additional object, which means more memory pressure, an extra dereference step. It would be a complete waste of time and memory to use WeakReference<T> to store an object that’s barely larger than WeakReference<T> itself. However, there are some caveats to this, below.

This might be a pretty big performance hit to do this every time there is an update. Instead, you could spread that cost around by having all of the secondary indexes use WeakReference instead: Dictionary<DateTime, WeakReference<Person>>, or, if the index has non-unique keys (likely), Dictionary<DateTime, List<WeakReference<Person>>>.

By doing this, the cleanup process becomes much easier: you just update the master cache, which removes the only strong reference to the object. The next time a garbage collection runs (of the appropriate generation), the Person object will be cleaned up. If you ever access a secondary index looking for those objects, you’ll discover the object has been cleaned up, and you can clean up those indexes right then. This spreads out the cost of cleanup of the index overhead, while allowing the expensive cached objects to be cleaned up earlier.

Other Uses

This Stack Overflow thread has some additional thoughts, with some variations of the example below and other uses.

A rather famous and involved example is using WeakReferences to prevent the dangling event handler problem (where failure to unregister an event handler keeps objects in memory, despite them having no explicit references anywhere in your code).

Practical Example

I had mentioned in Chapter 2 (Garbage Collection) of Writing High-Performance .NET Code that WeakReference could be used in a multilevel caching system to allow objects to gracefully fall out of memory when pressure increases. You can start with strong references and then demote them to weak references according to some criteria you choose.

That is the example I’ll show here. Note that this not production-quality code. It’s only about 5% of the code you would actually need, even assuming this algorithm makes sense in your scenario. At a minimum, you probably want to implement IDictionary<TKey, TValue> on it, perhaps tighten up some of the temporary memory allocations, and more.

This is a very simple implementation. When you add items to the cache, it adds them as strong references (removing any existing weak references for that key). When you attempt to read a value from the cache, it tries the strong references first, before attempting the weak references.

Objects are demoted from strong to weak references based simply on a maximum age. This is admittedly rather simplistic, but it gets the point across.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;

namespace WeakReferenceCache
{
    sealed class HybridCache<TKey, TValue> 
        where TValue:class
    {
        class ValueContainer<T>
        {
            public T value;
            public long additionTime;
            public long demoteTime;
        }

        private readonly TimeSpan maxAgeBeforeDemotion;

        private readonly ConcurrentDictionary<TKey, ValueContainer<TValue>> strongReferences = 
            new ConcurrentDictionary<TKey, ValueContainer<TValue>>();
        private readonly ConcurrentDictionary<TKey, WeakReference<ValueContainer<TValue>>> weakReferences = 
            new ConcurrentDictionary<TKey, WeakReference<ValueContainer<TValue>>>();
                
        public int Count
        {
            get { return this.strongReferences.Count; }
        }

        public int WeakCount 
        { 
            get 
            { 
                return this.weakReferences.Count; 
            } 
        }

        public HybridCache(TimeSpan maxAgeBeforeDemotion)
        {
            this.maxAgeBeforeDemotion = maxAgeBeforeDemotion;
        }

        public void Add(TKey key, TValue value)
        {
            RemoveFromWeak(key);
            var container = new ValueContainer<TValue>();
            container.value = value;
            container.additionTime = Stopwatch.GetTimestamp();
            container.demoteTime = 0;
            this.strongReferences.AddOrUpdate(key, container, (k, existingValue) => container);
        }

        private void RemoveFromWeak(TKey key)
        {
            WeakReference<ValueContainer<TValue>> oldValue;
            weakReferences.TryRemove(key, out oldValue);
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            value = null;
            ValueContainer<TValue> container;
            if (this.strongReferences.TryGetValue(key, out container))
            {
                AttemptDemotion(key, container);
                value = container.value;
                return true;
            }

            WeakReference<ValueContainer<TValue>> weakRef;
            if (this.weakReferences.TryGetValue(key, out weakRef))
            {
                if (weakRef.TryGetTarget(out container))
                {
                    value = container.value; 
                    return true;
                }
                else
                {
                    RemoveFromWeak(key);
                }
            }
            return false;
        }

        public void DemoteOldObjects()
        {
            var demotionList = new List<KeyValuePair<TKey, ValueContainer<TValue>>>();
            long now = Stopwatch.GetTimestamp();

            foreach(var kvp in this.strongReferences)
            {
                var age = CalculateTimeSpan(kvp.Value.additionTime, now);
                if (age > this.maxAgeBeforeDemotion)
                {
                    demotionList.Add(kvp);
                }
            }

            foreach(var kvp in demotionList)
            {
                Demote(kvp.Key, kvp.Value);
            }
        }

        private void AttemptDemotion(TKey key, ValueContainer<TValue> container)
        {
            long now = Stopwatch.GetTimestamp();
            var age = CalculateTimeSpan(container.additionTime, now);
            if (age > this.maxAgeBeforeDemotion)
            {
                Demote(key, container);
            }           
        }

        private void Demote(TKey key, ValueContainer<TValue> container)
        {
            ValueContainer<TValue> oldContainer;
            this.strongReferences.TryRemove(key, out oldContainer);
            container.demoteTime = Stopwatch.GetTimestamp();
            var weakRef = new WeakReference<ValueContainer<TValue>>(container);
            this.weakReferences.AddOrUpdate(key, weakRef, (k, oldRef) => weakRef);
        }

        private TimeSpan CalculateTimeSpan(long offsetA, long offsetB)
        {
            long diff = offsetB - offsetA;
            double seconds = (double)diff / Stopwatch.Frequency;
            return TimeSpan.FromSeconds(seconds);
        }        
    }
}

That’s it for the series on Weak References–I hope you enjoyed it! You may never need them, but when you do, you should understand how they work in detail to make the smartest decisions.

Check out my latest book, the essential, in-depth guide to performance for all .NET developers:

Writing High-Performance.NET Code by Ben Watson. Available now in print and as an eBook at:

• Amazon
• Barnes and Noble
• and more, see book site