Filtruj wszystkie właściwości nawigacji zanim zostaną załadowane (leniwe lub chętne) do pamięci

Po wielu badaniach, w końcu znalazłem sposób, aby osiągnąć to, czego chciałem. Chodzi o to, że przechwytywam zmaterializowane byty za pomocą obsługi zdarzeń w kontekście obiektu, a następnie wprowadzam własną klasę collection do każdej właściwości kolekcji ,którą mogę znaleźć(z odbiciem).

Najważniejszą częścią jest przechwycenie "DbCollectionEntry", klasy odpowiedzialnej za ładowanie powiązanych właściwości kolekcji. Poruszając się pomiędzy istotą a DbCollectionEntry, ja zyskaj pełną kontrolę nad tym, co jest ładowane, kiedy i jak. Jedynym minusem jest to, że ta klasa DbCollectionEntry ma niewiele lub nie ma członków publicznych, co wymaga ode mnie użycia reflection, aby nią manipulować.

Oto moja klasa custom collection, która implementuje ICollection i zawiera odniesienie do odpowiedniego DbCollectionEntry:

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
}

Jeśli przejrzysz ją, przekonasz się, że najważniejszą częścią jest właściwość "Entities", która leniwie ładuje rzeczywiste wartości. W konstruktor FilteredCollection przekazuję opcjonalną ICollection dla scenariuszy, w których kolekcja jest już chętnie ładowana.

Oczywiście nadal musimy skonfigurować strukturę encji tak, aby nasz FilteredCollection był używany wszędzie tam, gdzie istnieją właściwości kolekcji. Można to osiągnąć poprzez podłączenie do zdarzenia Obiektmaterialized podstawowego Obiektkontekstu struktury podmiotu:

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

To wszystko wygląda dość skomplikowanie, ale to, co robi zasadniczo, to skanowanie Typ zmaterializowany dla właściwości kolekcji i zmień wartość na przefiltrowaną kolekcję. Przekazuje również DbCollectionEntry do filtrowanej kolekcji, dzięki czemu może działać magicznie.

Obejmuje to całą część "jednostki ładujące". Jak dotąd jedynym minusem jest to, że chętnie załadowane właściwości kolekcji nadal będą zawierać usunięte encje, ale są one filtrowane metodą 'Add' klasy FilterCollection. Jest to akceptowalny minus, chociaż muszę jeszcze wykonać kilka testów jak to wpływa na metodę SaveChanges ().

Oczywiście pozostaje jeszcze jeden problem: nie ma automatycznego filtrowania zapytań. Jeśli chcesz pobrać członków siłowni, którzy wykonali trening w ciągu ostatniego tygodnia, chcesz automatycznie wykluczyć usunięte treningi.

Uzyskuje się to za pomocą funkcji ExpressionVisitor, która automatycznie stosuje a'.Gdzie (e =>!e. Deleted) ' filtr do każdego IQueryable, który może znaleźć w danym wyrażeniu.

Oto kod:

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

Jestem trochę brakuje czasu, więc wrócę do tego posta później z więcej szczegółów, ale sedno jest zapisane i dla tych z was chętnych do wypróbowania wszystkiego; zamieściłem pełną aplikację testową tutaj: {24]} https://github.com/amoerie/TestingGround

Jednak nadal mogą wystąpić pewne błędy, ponieważ jest to bardzo dużo pracy w toku. Pomysł koncepcyjny jest jednak solidny i spodziewam się, że wkrótce będzie w pełni funkcjonował, gdy wszystko porządnie zrefakturuję i znajdę czas na napisz kilka testów do tego.