tables Lookup meilleures pratiques

Question

Dans mon DB J'ai beaucoup des recherches, ce qui aura une interface utilisateur pour changer, j'ai MVC site web, et que vous souhaitez avoir les recherche chargés une fois, et rafraîchi si des changements ont eu lieu

mes données couche d'accès ressemble à:

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); 
} 

et pour obtenir la liste de recherche J'utilise comme méthode

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); 
    } 
} 

toute idée de gérer la situation dans laquelle je discutais ci-dessus pour les charger une fois i f toute modification les recharger j'appelle cette méthode à mon MVC en utilisant le service Web

Answer 1

Je voudrais avoir une classe CachedLookup qui a un champ IEnumerable pour chaque type (ou même un Dictionary<Type,IEnumerable<T>>) qui contient le résultat mis en cache, puis GetLookup serait un méthode non statique de cette classe. Cela retournerait le champ si aucun changement n'est survenu.

La façon dont vous voulez que le cache soit invalidé dépendra. Si vous souhaitez que la recherche soit mise à jour dans un délai raisonnable (pas immédiatement), vous pouvez avoir une dernière mise à jour, puis vérifier l'heure actuelle (sur l'appel GetLookup) si 30min après la dernière date et rafraîchir le cache . Si vous voulez qu'il soit immédiat et qu'il existe une action dans votre application qui invalide le cache, vous pouvez utiliser une méthode InvalidateCache<T>() qui actualise ce cache spécifique. Le CachedLookup saura comment actualiser le cache et sera juste un proxy pour aller chercher les recherches.