从赵劼 的博客中看的的方法，通过泛型建立一个泛型数据缓存，略加改进。
闲话少说，上代码

最原始的样子

static class DataCache<TModel>{
    public IEnumerable<TModel> Cache{get;set;}
}

哈哈，就这么简单，需要自己设置缓存数据并获取，没有任何的应用逻辑
非常方便的说。
.Net 运行时会安排缓存数据的存放，保证不同类型的数据不会搞混。

不过这样太简单了，增加一点功能，从 DataContext 中直接加载缓存数据。

static class DataCache<TModel>{
    private IEnumerable<TModel> Cache{get;set;}

    public static IEnumerable<TModel> GetCacheData<TDataContext>(TDataContext dataContext)
            where TDataContext : DataContext{
            if (dataContext == null){
                throw new ArgumentNullException("dataContext");
            }
            if (CacheData == null){
                CacheData = dataContext.GetTable<TModel>().ToList();
            }
            return CacheData;
        }
}

不同的 DataContext 子类加载的数据都会放在一起，但是通常 不同的 DataContext 命名空间不会一样，也不会有相同的表，所以尽可以放心使用。

最后一个问题，如何清理缓存，当数据变化时，需要重新加载缓存，没什么好办法，把缓存清理之后，再次访问的时候就会重新加载数据。
通常有两种情况，本程序数据修改和其他客户端进行的数据修改。
没有数据修改的通知，只好自己清理缓存了。

基类 IGenericsCache 建立了一个清理缓存方法的列表，每次加载数据就会增加一个方法，需要全部清理的时候执行一下就可以了。

    /// <summary>
    /// 泛型数据缓存基类 定义 清除全部缓存功能
    /// 在继承类中，实现获取缓存的方法中 必须增加一个清理缓存的 活动
    /// </summary>
    public class IGenericsCache{
        /// <summary>
        /// 保存 清理缓存的 <see cref="Action"/>
        /// </summary>
        protected static readonly List<Action> ClearCacheActions = new List<Action>();

        /// <summary>
        /// 清理全部缓存
        /// </summary>
        public static void ClearAllCache(){
            foreach (Action action in ClearCacheActions){
                Console.WriteLine(action);
                action.Invoke();
            }
            ClearCacheActions.Clear();
        }
    }


    /// <summary>
    ///     Linq 数据源 静态泛型缓存
    /// </summary>
    /// <typeparam name="TModel"></typeparam>
    public class GenericsCache<TModel> : IGenericsCache where TModel : class{
        private static IEnumerable<TModel> CacheData { get; set; }

        /// <summary>
        ///     获取缓存
        /// </summary>
        /// <param name="dataContext"></param>
        /// <returns></returns>
        public static IEnumerable<TModel> GetCacheData<TDataContext>(TDataContext dataContext)
            where TDataContext : DataContext{
            if (dataContext == null){
                throw new ArgumentNullException("dataContext");
            }
            if (CacheData == null){
                CacheData = dataContext.GetTable<TModel>().ToList();
                ClearCacheActions.Add(() => CacheData = null);
            }
            return CacheData;
        }

        public static IEnumerable<TModel> GetCacheData<TDataContext>(TDataContext dataContext,
                                                                     Func<TDataContext, IEnumerable<TModel>>
                                                                         dataAccesser) where TDataContext : DataContext{
            if (dataContext == null){
                throw new ArgumentNullException("dataContext");
            }
            if (CacheData == null){
                CacheData = dataAccesser.Invoke(dataContext).ToList();
                ClearCacheActions.Add(() => CacheData = null);
            }
            return CacheData;
        }


        /// <summary>
        ///     清理 <see cref="TModel">当前类型</see>的缓冲缓存
        /// </summary>
        public static void ClearCache(){
            CacheData = null;
        }
    }

以前总是想着 利用一个字典什么的，可以了解哪些数据被缓存了，后来发现这样一来，泛型缓存就没有意义了，只是形式上的泛型方法而已，内部实现还是需要获取类型，那还泛型干什么。

限制，程序中不保证 TModel 一定属于 TDataContext ，如果不属于，请使用第二个方法

Func<TDataContext, IEnumerable<TModel>> dataAccesser

通过一个类型转换，可以缓存任意类型的数据，可以完全和 TDataContext 无关。