Generic MemoryCache class I want to have a caching class to cache different types.  I want each type to be cached in a different MemoryCache but in a generic way.

Am I doing it right? 

internal static class RecordsCache
{
    private static Dictionary&lt;string, ObjectCache&gt; cacheStore;
    static private CacheItemPolicy policy = null;

    static RecordsCache()
    {
        cacheStore = new Dictionary&lt;string, ObjectCache&gt;();

        ObjectCache activitiesCache = new MemoryCache(typeof(Activity).ToString());
        ObjectCache lettersCache = new MemoryCache(typeof(Letter).ToString());
        ObjectCache contactssCache = new MemoryCache(typeof(Contact).ToString());

        cacheStore.Add(typeof(Activity).ToString(), activitiesCache);
        cacheStore.Add(typeof(Letter).ToString(), lettersCache );
        cacheStore.Add(typeof(Contact).ToString(), contactssCache );

        policy = new CacheItemPolicy();
        policy.Priority = CacheItemPriority.Default;
        policy.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
    }

    public static void Set&lt;T&gt;(string userID, int year, List&lt;T&gt; records)
    {
        var cache = cacheStore[typeof(T).ToString()];
        string key = userID + "-" + year.ToString();
        cache.Set(key, records, policy);
    }

    public static bool TryGet&lt;T&gt;(string userID, int year, out List&lt;T&gt; records)
    {
        var cache = cacheStore[typeof(T).ToString()];
        string key = userID + "-" + year.ToString();

        records = cache[key] as List&lt;T&gt;;
        return records != null;
    }

    public static void Remove&lt;T&gt;(string userID, int year)
    {
        var cache = cacheStore[typeof(T).ToString()];
        string key = userID + "-" + year.ToString();
        cache.Remove(key);
    }
}
Instead of having a cache

private static Dictionary&lt;string, ObjectCache&gt; cacheStore;


you could have one keyed of the types:

private static Dictionary&lt;Type, ObjectCache&gt; cacheStore;


This means you don't need to call typeof(T).ToString() everywhere.
You duplicate the code of building the key in all 3 methods - it should be extracted into a private BuildKey(string userId, int year) method. This means if you need to change how the key is built you only need to touch one method rather than all of them.
I would provide a Register method which accepts a type for which to create a new cache rather than hard-coding it in.
The cache policy is also not configurable - which means you are stuck with it unless you want to change the code.
You really really should think hard about whether a static cache is the right way to go. It will give you trouble in unit testing and it will also make it impossible for multiple classes to have different cache with different policies for example.