C# 查找表最佳实践

在我的数据库中，我有许多查找，其中将有一个用于更改的UI，我有MVC网站，并且希望这些查找加载一次，如果发生任何更改，则刷新

我的数据访问层看起来像：

private ClassessEntities Context;
protected Repository()
{
    Context = new ArabicEWorldEntities();
}
public IEnumerable<T> Get(Expression<Func<T, bool>> predicate)
{
    return Context.CreateObjectSet<T>().Where(predicate).ToList();
}
public T First(Expression<Func<T, bool>> predicate)
{
    return Context.CreateObjectSet<T>().Where(predicate).FirstOrDefault();
}
public IEnumerable<T> GetAll()
{
    return Context.CreateObjectSet<T>().ToList();
}
public IEnumerable<T> GetAllOrderBy(Func<T, object> keySelector)
{
    return Context.CreateObjectSet<T>().OrderBy(keySelector).ToList();
}
public IEnumerable<T> GetAllOrderByDescending(Func<T, object> keySelector)
{
    return Context.CreateObjectSet<T>().OrderByDescending(keySelector).ToList();
}
public void Commit()
{
    Context.SaveChanges();
}
public void Add(T entity)
{
    Context.CreateObjectSet<T>().AddObject(entity);
}
public void Update(T entity)
{
    Context.ObjectStateManager.ChangeObjectState(entity, System.Data.EntityState.Modified);
    Context.SaveChanges();
}
public void Delete(T entity)
{
    Context.DeleteObject(entity);
    Context.SaveChanges();
}
public void Dispose()
{
    if (Context != null)
    {
        Context.Dispose();
    }
    GC.SuppressFinalize(this);
}

私有类本质上下文；
受保护的存储库（）
{
上下文=新的ArabicEWorldEntities（）；
}
公共IEnumerable Get（表达式谓词）
{
返回Context.CreateObjectSet（）.Where（谓词）.ToList（）；
}
公共T优先（表达式谓词）
{
返回Context.CreateObjectSet（）.Where（谓词）.FirstOrDefault（）；
}
公共IEnumerable GetAll（）
{
返回Context.CreateObjectSet（）.ToList（）；
}
公共IEnumerable GetAllOrderBy（Func键选择器）
{
返回Context.CreateObjectSet（）.OrderBy（keySelector.ToList（）；
}
公共IEnumerable GetAllOrderByDescending（Func键选择器）
{
返回Context.CreateObjectSet（）.OrderByDescending（keySelector.ToList（）；
}
公共无效提交（）
{
SaveChanges（）；
}
公共无效添加（T实体）
{
Context.CreateObjectSet（）.AddObject（实体）；
}
公共无效更新（T实体）
{
Context.ObjectStateManager.ChangeObjectState（entity、System.Data.EntityState.Modified）；
SaveChanges（）；
}
公共作废删除（T实体）
{
删除对象（实体）；
SaveChanges（）；
}
公共空间处置（）
{
if（上下文！=null）
{
Context.Dispose（）；
}
总干事（本）；
}

为了从查找中获得列表，我使用如下方法

private static ClassesEntities Context;

public static IEnumerable<T> GetLookup<T>() where T : System.Data.Objects.DataClasses.EntityObject
{
    try
    {
        var key = typeof(T).Name;
        // 1. we need the container for the conceptual model
        var container = Context.MetadataWorkspace.GetEntityContainer(
            Context.DefaultContainerName, System.Data.Metadata.Edm.DataSpace.CSpace);
        // 2. we need the name given to the element set in that conceptual model
        var name = container.BaseEntitySets.Where((s) => s.ElementType.Name.Equals(key)).FirstOrDefault().Name;
        // 3. finally, we can create a basic query for this set
        var query = Context.CreateQuery<T>("[" + name + "]");

        return query.ToList();
    }
    catch (System.Data.EntityException ex)
    {
        throw new ArgumentException("Invalid Entity Type supplied for Lookup", ex);
    }
}

私有静态类实体上下文；
公共静态IEnumerable GetLookup（），其中T:System.Data.Objects.DataClasses.EntityObject
{
尝试
{
var key=typeof（T）.Name；
//1.我们需要用于概念模型的容器
var container=Context.MetadataWorkspace.GetEntityContainer(
Context.DefaultContainerName、System.Data.Metadata.Edm.DataSpace.CSpace）；
//2.我们需要该概念模型中元素集的名称
var name=container.BaseEntitySets.Where（（s）=>s.ElementType.name.Equals（key））.FirstOrDefault（）.name；
//3.最后，我们可以为这个集合创建一个基本查询
var query=Context.CreateQuery（“[”+name+“]）；
返回query.ToList（）；
}
捕获（System.Data.EntityException ex）
{
抛出新ArgumentException（“为查找提供的实体类型无效”，ex）；
}
}

---

任何处理我上面讨论过的情况的想法都可以加载它们一次，如果有任何更改，我会使用web服务将这些方法调用到我的MVC中，我会有一个CachedLookup类，每个类型都有一个IEnumerable字段（甚至是一个

字典

）包含缓存结果，然后GetLookup将是该类的非静态方法。如果没有发生任何更改，它将返回该字段

您希望缓存如何失效将取决于。如果您希望在合理的时间内（即不是立即）更新查找，您可以有一个上次更新的时间，然后检查当前时间（在GetLookup调用中），如果它是在上次日期后30分钟，则刷新缓存。如果您希望它是即时的，并且应用程序中存在使缓存无效的某些操作，则可以使用一个刷新特定缓存的

InvalidateCache（）

方法

CachedLookup将知道如何刷新缓存，并且只是获取查找的代理