public JsonDocument[] GetDocument(params string[] ids) { // only ask server for uncached documents var uncachedIds = (from id in ids where !cache.Contains(id) select id).ToArray();

// make the request to the server, for example
var request = WebRequest.Create("http://server/get?id=" + string.Join("&id=", uncachedIds));
using (var stream = request.GetResponse().GetResponseStream())
{
    var results = GetResults(stream);
    // add fetched documents to cache
    foreach (var x in uncachedIds.Zip(results, (id, doc) => new { id, doc }))
    {
        cache[x.id] = x.doc;
    }
}

// return all documents form cache
return (from id in ids select (JsonDocument)cache[id]).ToArray();

}

class ElegantCache<TKey, TValue>
{
    private readonly Dictionary<TKey, TValue> _cache = new Dictionary<TKey, TValue>(); 
    private readonly Func<TValue, TKey> _keyResolver;
    private readonly Func<IEnumerable<TKey>, IEnumerable<TValue>> _uncachedResolver;

    public ElegantCache(Func<TValue, TKey> keyResolver, Func<IEnumerable<TKey>, IEnumerable<TValue>> uncachedResolver)
    {
        _keyResolver = keyResolver;
        _uncachedResolver = uncachedResolver;
    }

    public IEnumerable<TValue> Get(TKey[] keys)
    {
        var uncachedKeys = keys.Except(_cache.Keys).ToList();
        if (uncachedKeys.Count > 0)
        {
            foreach (var value in _uncachedResolver(uncachedKeys))
            {
                _cache.Add(_keyResolver(value), value);
            }
        }
        return keys.Join(_cache, k => k, kvp => kvp.Key, (k, kvp) => kvp.Value);
    }
}

Revised: keys.Join line was abominable.

class ElegantCache<TKey, TValue>
{
    private readonly Dictionary<TKey, TValue> _cache = new Dictionary<TKey, TValue>(); 
    private readonly Func<TValue, TKey> _keyResolver;
    private readonly Func<IEnumerable<TKey>, IEnumerable<TValue>> _uncachedResolver;

    public ElegantCache(Func<TValue, TKey> keyResolver, Func<IEnumerable<TKey>, IEnumerable<TValue>> uncachedResolver)
    {
        _keyResolver = keyResolver;
        _uncachedResolver = uncachedResolver;
    }

    public IEnumerable<TValue> Get(TKey[] keys)
    {
        var uncachedKeys = keys.Except(_cache.Keys).ToList();
        if (uncachedKeys.Count > 0)
        {
            foreach (var value in _uncachedResolver(uncachedKeys))
            {
                _cache.Add(_keyResolver(value), value);
            }
        }
        return keys.Select(key => _cache[key]);
    }
}

Non-leaking version:

class ElegantCache<TValue> : IDisposable
{
    private readonly MemoryCache _cache = new MemoryCache(Guid.NewGuid().ToString());
    private readonly CacheItemPolicy _cacheItemPolicy;
    private readonly Func<TValue, string> _keyResolver;
    private readonly Func<IEnumerable<string>, IEnumerable<TValue>> _uncachedResolver;

    public ElegantCache(CacheItemPolicy cacheItemPolicy, Func<TValue, string> keyResolver, Func<IEnumerable<string>, IEnumerable<TValue>> uncachedResolver)
    {
        _cacheItemPolicy = cacheItemPolicy;
        _keyResolver = keyResolver;
        _uncachedResolver = uncachedResolver;
    }

    public IEnumerable<TValue> Get(string[] keys)
    {
        var values = _cache.GetValues(keys) ?? new Dictionary<string, object>();
        if (values.Count < keys.Length)
        {
            foreach (var value in _uncachedResolver(keys.Except(values.Keys)))
            {
                values.Add(_keyResolver(value), value);
                _cache.Add(_keyResolver(value), value, _cacheItemPolicy);
            }
        }
        return keys.Select(key => values[key]).Cast<TValue>();
    }

    public void Dispose()
    {
        _cache.Dispose();
    }
}

Non-leaking, more performant, thread-safe...

class ElegantCache<TValue> : IDisposable
{
    private readonly MemoryCache _cache = new MemoryCache(Guid.NewGuid().ToString());
    private readonly CacheItemPolicy _cacheItemPolicy;
    private readonly Func<TValue, string> _keyResolver;
    private readonly Func<IEnumerable<string>, IEnumerable<TValue>> _uncachedResolver;

    public ElegantCache(CacheItemPolicy cacheItemPolicy, Func<TValue, string> keyResolver, Func<IEnumerable<string>, IEnumerable<TValue>> uncachedResolver)
    {
        _cacheItemPolicy = cacheItemPolicy;
        _keyResolver = keyResolver;
        _uncachedResolver = uncachedResolver;
    }

    public IEnumerable<TValue> Get(string[] keys)
    {
        var values = _cache.GetValues(keys) ?? new Dictionary<string, object>();
        if (values.Count < keys.Length)
        {
            foreach (var value in _uncachedResolver(keys.Where(k => !values.ContainsKey(k))))
            {
                var key = _keyResolver(value);
                values.Add(key, _cache.AddOrGetExisting(key, value, _cacheItemPolicy));
            }
        }
        return keys.Select(key => values[key]).Cast<TValue>();
    }

    public void Dispose()
    {
        _cache.Dispose();
    }
}

Ayende,

Your use case for the proxy showed it being used and disposed in a very short space of time, so memory leakage, thread-safety and performance around the overall size of the cache were not an obvious part of your requirements. You simplified the problem drastically, I simplified the solution likewise.

While we're in code review mode, your server method is inefficient in terms of collection management. You should create the List with the known size to prevent array copies as the list resizes its internals, or, even better, just create the array and then use a for loop to populate it:

public JsonDocument[] GetDocument(string[] ids)
{
  var  results = new JsonDocument[ids.Length];
  for(int i = 0; i < ids.Length; i++)
  {
    results[i] = GetDocument(ids[i]);
  }
  return results;  
}

While I'm learning about MemoryCache, which is great, more and more requirements are rearing their heads here.

class ElegantCache<TValue> : IDisposable
{
    private readonly MemoryCache _cache = new MemoryCache(Guid.NewGuid().ToString());
    private readonly CacheItemPolicy _cacheItemPolicy;
    private readonly Func<TValue, string> _keyResolver;
    private readonly Func<IEnumerable<string>, IEnumerable<TValue>> _uncachedResolver;

    public ElegantCache(CacheItemPolicy cacheItemPolicy, Func<TValue, string> keyResolver, Func<IEnumerable<string>, IEnumerable<TValue>> uncachedResolver)
    {
        _cacheItemPolicy = cacheItemPolicy;
        _keyResolver = keyResolver;
        _uncachedResolver = uncachedResolver;
    }

    public IEnumerable<TValue> Get(string[] keys)
    {
        var values = _cache.GetValues(keys) ?? new Dictionary<string, object>();
        if (values.Count < keys.Length)
        {
            foreach (var value in _uncachedResolver(keys.Where(k => values[k] == null)))
            {
                var key = _keyResolver(value);
                values[key] = value;
                _cache.Set(key, value, _cacheItemPolicy);
            }
        }
        return keys.Select(key => values[key]).Cast<TValue>();
    }

    public void Dispose()
    {
        _cache.Dispose();
    }
}

I'm not making multiple DB calls, the _uncachedResolver function takes a list of strings and returns a list of values. The function would look like:

ids =>
{
    var request = WebRequest.Create("http://server/get?id=" + string.Join("&id=", ids));
    using (var stream = request.GetResponse().GetResponseStream())
    {
        return GetResults(stream);
    }
}

Also, I'm probably doing something hideous with my creation of the MemoryCache class with a GUID as the name. I suspect a better way would be to use a named region in the Default cache.

Yes, I forgot to fix that check line to account for Nulls in the dictionary that comes back from the cache. So that line should be

if (values.Any(kvp => kvp.Value == null))

and done.

Interesting to note that if you post enough comments, the Captcha stops appearing. Nice UX.

I've posted that class along with how it would be used by ClientProxy as a gist: https://gist.github.com/1167813

I rather like Mark's solution.

Mark,

1 small bug, the line foreach (var value in _uncachedResolver(keys.Where(k => values[k] == null)))

should be foreach (var value in _uncachedResolver(keys.Where(k => !values.ContainsKey(k))))

Otherwise it throws an exception when the key isn't in a cache rather than fetching it.

Matt,

MemoryCache returns all the keys in the Dictionary, with nulls where there was no matching value.

I think that only applies if you're using the GetValues(..) method, but not if you're using the Indexer or Item property (see http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache.item.aspx).

Either way it's a small detail and I like the your solution

Matt: I am using GetValues.

@Ayende, can we see your solution about this challenge?

@Mark, regarding list/array optimization, I think Linq would be most efficient solution. E.g. ids.Select(GetDocument).ToArray();

@Ayende, regarding thread-safetiness, why does that matter. Why is it important that 2 concurrent requests with the same id MUST make exactly 1 request? I think the performance overhead to ensure this requirement (i.e. locking) would outweigh its gain.