Question

Would it work to use Expression<Func<T>> or Func<T> as keys in a dictionary? For example to cache the result of heavy calculations.

For example, changing my very basic cache from a different question of mine a bit:

public static class Cache<T>
{
    // Alternatively using Expression<Func<T>> instead
    private static Dictionary<Func<T>, T> cache;
    static Cache()
    {
        cache = new Dictionary<Func<T>, T>();
    }
    public static T GetResult(Func<T> f)
    {
        if (cache.ContainsKey(f))
            return cache[f];

       return cache[f] = f();
    }
}

Would this even work?

Edit: After a quick test, it seems like it actually works. But I discovered that it could probably be more generic, since it would now be one cache per return type… not sure how to change it so that wouldn’t happen though… hmm

Edit 2: Noo, wait… it actually doesn’t. Well, for regular methods it does. But not for lambdas. They get various random method names even if they look the same. Oh well c”,)

Answer 1

You can use any type of object, as long as it is an instance. That even being a delegate, but I do not recommend using delegates as keys because they are not designed for that. I’m not sure that independently created delegates produce the same hash code, even less if they can be compared (equatable).