EF 4.1 Code Premier filtrage des collections chargées paresseuses

Question

J'ai le code EF Première solution qui supporte la suppression logicielle, donc nous marquons les entités comme IsDeleted et ne les retirons pas de la base de données. Je voudrais regrouper les objets associés (chargement différé) afin que les entités marquées comme supprimées ne soient pas renvoyées à l'utilisateur de l'API.

Voici approache simple, j'utilise:

public class FilteredCollection<T> : ICollection<T> where T : DeletableEntity 
{ 
    private List<T> _listWithDeleted = new List<T>(); 

    protected IEnumerable<T> FilteredItems 
    { 
     get { return _listWithDeleted.Where(e => e.IsDeleted == false); } 
    } 

    protected bool _IsReadOnly; 

    public virtual T this[int index] 
    { 
     get 
     {     
      return FilteredItems.ToList()[index]; 
     } 
     set 
     { 
      FilteredItems.ToList()[index] = value; 
     } 
    } 

    public virtual int Count 
    { 
     get 
     { 
      return FilteredItems.Count(); 
     } 
    } 

    public virtual bool IsReadOnly 
    { 
     get 
     { 
      return _IsReadOnly; 
     } 
    } 

    public virtual void Add(T entityObject) 
    { 
     _listWithDeleted.Add(entityObject); 
    } 

    public virtual bool Remove(T entityObject) 
    { 
     if (FilteredItems.Contains(entityObject)) 
     { 
      entityObject.IsDeleted = true; 
      return true; 
     } 
     else 
     { 
      return false;  
     } 
    } 

    public bool Contains(T entityObject) 
    { 
     return FilteredItems.Contains(entityObject); 
    } 

    public virtual void CopyTo(T[] entityObjectArray, int index) 
    { 
     var list = FilteredItems.ToList(); 
     list.CopyTo(entityObjectArray, index); 
    } 

    public virtual void Clear() 
    { 
     foreach (var item in _listWithDeleted) 
     { 
      item.IsDeleted = true; 
     } 
    } 

    public virtual IEnumerator<T> GetEnumerator() 
    { 
     return FilteredItems.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return FilteredItems.GetEnumerator(); 
    } 
} 

J'ai mis en ICollection il filtre l'objet en interne. J'utilise cette classe au lieu de ICollection pour que les entités filtrées me soient renvoyées. J'ai fait quelques tests et il semble que cela fonctionne bien, mais je ne me sens pas à l'aise avec cette solution.

Pourriez-vous s'il vous plaît me fournir des inconvénients de cette approche ou s'il vous plaît suggérer au cas où vous en connaissez un meilleur.

Merci d'avance,

-Petro

Answer 1

Il est mauvaise solution car elle rend le filtrage dans votre application. Si votre base de données augmente et qu'il y a de plus en plus d'éléments supprimés, vous devrez toujours les charger avant d'appliquer le filtre. Cela peut rapidement devenir un très gros problème de performance.

Vous devriez faire un filtrage dans la base de données, mais cela va à l'encontre du chargement paresseux et impatient. La solution peut être un mappage conditionnel (seuls les éléments non supprimés seront mappés) mais il ne vous permettra pas de mapper la propriété IsDeleted - vous devrez supprimer votre entité avec la procédure stockée et celle-ci ne pourra pas être mappée avec le code.

Avec la combinaison du code EF d'abord + soft delete, vous devez éviter complètement le chargement paresseux et impatient et soit utiliser une requête séparée pour obtenir des données filtrées ou utiliser un chargement explicite.