Filtrer toutes les propriétés de navigation avant de les charger (paresseux ou impatient) dans la mémoire

après de nombreuses recherches, j'ai enfin trouvé un moyen de réaliser ce que je voulais. L'essentiel est que j'intercepte des entités matérialisées avec un gestionnaire d'événements dans le contexte de l'objet, puis j'injecte ma classe custom collection dans chaque propriété de collection que je peux trouver (avec réflexion).

la partie la plus importante est l'interception du" DbCollectionEntry", la classe responsable du chargement des propriétés de collecte liées. En me tortillant entre l'entité et la collecte DbCollectionEntry, je prends le contrôle total sur ce qui est chargé quand et comment. Le seul inconvénient est que cette classe de collecte de DbCollectionEntry a peu ou pas de membres du public, ce qui m'oblige à utiliser la réflexion pour la manipuler.

voici ma classe de collection personnalisée qui implémente ICollection et contient une référence à L'entry Dbcollection approprié:

public class FilteredCollection <TEntity> : ICollection<TEntity> where TEntity : Entity
{
    private readonly DbCollectionEntry _dbCollectionEntry;
    private readonly Func<TEntity, Boolean> _compiledFilter;
    private readonly Expression<Func<TEntity, Boolean>> _filter;
    private ICollection<TEntity> _collection;
    private int? _cachedCount;

    public FilteredCollection(ICollection<TEntity> collection, DbCollectionEntry dbCollectionEntry)
    {
        _filter = entity => !entity.Deleted;
        _dbCollectionEntry = dbCollectionEntry;
        _compiledFilter = _filter.Compile();
        _collection = collection != null ? collection.Where(_compiledFilter).ToList() : null;
    }

    private ICollection<TEntity> Entities
    {
        get
        {
            if (_dbCollectionEntry.IsLoaded == false && _collection == null)
            {
                IQueryable<TEntity> query = _dbCollectionEntry.Query().Cast<TEntity>().Where(_filter);
                _dbCollectionEntry.CurrentValue = this;
                _collection = query.ToList();

                object internalCollectionEntry =
                    _dbCollectionEntry.GetType()
                        .GetField("_internalCollectionEntry", BindingFlags.NonPublic | BindingFlags.Instance)
                        .GetValue(_dbCollectionEntry);
                object relatedEnd =
                    internalCollectionEntry.GetType()
                        .BaseType.GetField("_relatedEnd", BindingFlags.NonPublic | BindingFlags.Instance)
                        .GetValue(internalCollectionEntry);
                relatedEnd.GetType()
                    .GetField("_isLoaded", BindingFlags.NonPublic | BindingFlags.Instance)
                    .SetValue(relatedEnd, true);
            }
            return _collection;
        }
    }

    #region ICollection<T> Members

    void ICollection<TEntity>.Add(TEntity item)
    {
        if(_compiledFilter(item))
            Entities.Add(item);
    }

    void ICollection<TEntity>.Clear()
    {
        Entities.Clear();
    }

    Boolean ICollection<TEntity>.Contains(TEntity item)
    {
        return Entities.Contains(item);
    }

    void ICollection<TEntity>.CopyTo(TEntity[] array, Int32 arrayIndex)
    {
        Entities.CopyTo(array, arrayIndex);
    }

    Int32 ICollection<TEntity>.Count
    {
        get
        {
            if (_dbCollectionEntry.IsLoaded)
                return _collection.Count;
            return _dbCollectionEntry.Query().Cast<TEntity>().Count(_filter);
        }
    }

    Boolean ICollection<TEntity>.IsReadOnly
    {
        get
        {
            return Entities.IsReadOnly;
        }
    }

    Boolean ICollection<TEntity>.Remove(TEntity item)
    {
        return Entities.Remove(item);
    }

    #endregion

    #region IEnumerable<T> Members

    IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()
    {
        return Entities.GetEnumerator();
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()
    {
        return ( ( this as IEnumerable<TEntity> ).GetEnumerator() );
    }

    #endregion
}

si vous skim à travers elle, vous trouverez que la partie la plus importante est les " entités" propriété, qui chargera paresseusement les valeurs réelles. Dans le constructeur du FilteredCollection je passe une ICollection optionnelle pour scenario où la collection est déjà chargée avec impatience.

bien sûr, nous avons encore besoin de configurer le Framework Entity pour que notre collecteur FilteredCollection soit utilisé partout où il y a des propriétés de collecte. On peut y parvenir en se raccordant à L'événement Objectmatérialisé de L'Objectecontexte sous-jacent du cadre de L'entité:

(this as IObjectContextAdapter).ObjectContext.ObjectMaterialized +=
    delegate(Object sender, ObjectMaterializedEventArgs e)
    {
        if (e.Entity is Entity)
        {
            var entityType = e.Entity.GetType();
            IEnumerable<PropertyInfo> collectionProperties;
            if (!CollectionPropertiesPerType.TryGetValue(entityType, out collectionProperties))
            {
                CollectionPropertiesPerType[entityType] = (collectionProperties = entityType.GetProperties()
                    .Where(p => p.PropertyType.IsGenericType && typeof(ICollection<>) == p.PropertyType.GetGenericTypeDefinition()));
            }
            foreach (var collectionProperty in collectionProperties)
            {
                var collectionType = typeof(FilteredCollection<>).MakeGenericType(collectionProperty.PropertyType.GetGenericArguments());
                DbCollectionEntry dbCollectionEntry = Entry(e.Entity).Collection(collectionProperty.Name);
                dbCollectionEntry.CurrentValue = Activator.CreateInstance(collectionType, new[] { dbCollectionEntry.CurrentValue, dbCollectionEntry });
            }
        }
    };

tout cela semble assez compliqué, mais ce qu'il fait essentiellement est de scanner le type matérialisé pour les propriétés de collecte et de changer la valeur à une collecte filtrée. Il passe également le DbCollectionEntry à la collection filtrée de sorte qu'il peut travailler sa magie.

couvre l'ensemble de la partie "entités de chargement". Le seul inconvénient jusqu'à présent est que les propriétés de collection chargées avec enthousiasme incluront toujours les entités supprimées, mais elles sont filtrées dans la méthode " Add " de la classe FilterCollection. C'est un inconvénient acceptable, bien que je n'ai pas encore fait quelques tests sur la façon dont cela affecte la méthode SaveChanges ().

bien sûr, il reste un problème: il n'y a pas de filtrage automatique des requêtes. Si vous voulez récupérer les membres de la salle de gym qui ont fait une séance d'entraînement au cours de la dernière semaine, vous voulez exclure les séances d'entraînement supprimées automatiquement.

cela est réalisé par un viseur D'expression qui automatiquement applique la".Où (e=>!e.Supprimée) " filtre à chaque IQueryable, il peut se trouver dans une expression donnée.

voici le code:

public class DeletedFilterInterceptor: ExpressionVisitor
{
    public Expression<Func<Entity, bool>> Filter { get; set; }

    public DeletedFilterInterceptor()
    {
        Filter = entity => !entity.Deleted;
    }

    protected override Expression VisitMember(MemberExpression ex)
    {
        return !ex.Type.IsGenericType ? base.VisitMember(ex) : CreateWhereExpression(Filter, ex) ?? base.VisitMember(ex);
    }

    private Expression CreateWhereExpression(Expression<Func<Entity, bool>> filter, Expression ex)
    {
        var type = ex.Type;//.GetGenericArguments().First();
        var test = CreateExpression(filter, type);
        if (test == null)
            return null;
        var listType = typeof(IQueryable<>).MakeGenericType(type);
        return Expression.Convert(Expression.Call(typeof(Enumerable), "Where", new Type[] { type }, (Expression)ex, test), listType);
    }

    private LambdaExpression CreateExpression(Expression<Func<Entity, bool>> condition, Type type)
    {
        var lambda = (LambdaExpression) condition;
        if (!typeof(Entity).IsAssignableFrom(type))
            return null;

        var newParams = new[] { Expression.Parameter(type, "entity") };
        var paramMap = lambda.Parameters.Select((original, i) => new { original, replacement = newParams[i] }).ToDictionary(p => p.original, p => p.replacement);
        var fixedBody = ParameterRebinder.ReplaceParameters(paramMap, lambda.Body);
        lambda = Expression.Lambda(fixedBody, newParams);

        return lambda;
    }
}

public class ParameterRebinder : ExpressionVisitor
{
    private readonly Dictionary<ParameterExpression, ParameterExpression> _map;

    public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
    {
        _map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
    }

    public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
    {
        return new ParameterRebinder(map).Visit(exp);
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        ParameterExpression replacement;

        if (_map.TryGetValue(node, out replacement))
            node = replacement;

        return base.VisitParameter(node);
    }
}

je suis un peu à court sur le temps, donc je vais revenir à ce post plus tard avec plus de détails, mais l'essentiel de celui-ci est écrit et pour ceux d'entre vous désireux de tout essayer; j'ai posté l'application d'essai complète ici: https://github.com/amoerie/TestingGround

cependant, il pourrait y avoir encore quelques erreurs, car il s'agit d'un travail en cours. L'idée conceptuelle est bonne cependant, et je m'attends à ce qu'elle fonctionne pleinement bientôt une fois que j'aurai tout soigneusement remanié et trouver le temps d'écrire quelques tests pour cela.