Filter alle Navigations-Eigenschaften, bevor Sie geladen werden (lazy oder eager) in den Speicher

Nach viel Forschung, habe ich endlich einen Weg gefunden, das zu erreichen, was ich wollte.
Der Kern von ihm ist, dass ich abfangen materialisierte Personen mit einem event-handler am Objekt Kontext, und dann Spritzen meine benutzerdefinierten Auflistungsklasse in jeder Kollektion Eigenschaft, die ich finden kann (mit Reflexion).

Ist der wichtigste Teil abfangen der "DbCollectionEntry", die Klasse für die Beladung verantwortlich für die damit verbundene Sammlung von Eigenschaften. Durch wackeln mich zwischen die Entität und die DbCollectionEntry ich die volle Kontrolle über das, was geladen ist, Wann und wie. Der einzige Nachteil ist, dass diese DbCollectionEntry Klasse hat wenig bis gar keine öffentlichen Mitglieder, die verlangt von mir, reflektion verwenden, um es zu manipulieren.

Hier ist meine eigene collection-Klasse, die ICollection implementiert und enthält einen Verweis auf die entsprechende 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
}

Wenn Sie Blättern Sie durch es, werden Sie feststellen, dass der wichtigste Teil ist die "Einheiten" - Eigenschaft, die wird lazy load werden die tatsächlichen Werte. Im Konstruktor der FilteredCollection ich passiere ein optionales ICollection für das Szenario ist, wo die Sammlung wird bereits mit Spannung geladen.

Natürlich müssen wir noch konfigurieren, Entity Framework, so dass unsere FilteredCollection wird überall dort eingesetzt, wo es der Sammlung-Eigenschaften. Dies kann erreicht werden durch Einhaken in die ObjectMaterialized Veranstaltung von der zugrunde liegenden ObjectContext von Entity Framework:

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

Es sieht alles ziemlich kompliziert, aber was er im Grunde macht, ist, Scannen Sie die materialisierte geben für die Sammlung von Eigenschaften, und ändern Sie den Wert einer gefilterten Sammlung. Es geht auch bei der DbCollectionEntry, um die gefilterte Auflistung, so kann es die Arbeit seiner Magie.

Diese umfasst das gesamte "be-Organisationen" Teil. Der einzige Nachteil bisher ist, dass Spannung geladen Kollektion Eigenschaften ist immer noch die gelöschten Entitäten, sondern Sie sind gefiltert in der " Add " - Methode des FilterCollection-Klasse. Dies ist ein akzeptabler Nachteil, obwohl, ich habe noch zu tun einige Tests auf, wie sich dies auf die SaveChanges () - Methode.

Natürlich, dies lässt allerdings noch ein Problem: es gibt keine automatische Filterung, die auf die Abfragen. Wenn Sie möchten, Holen Sie sich das Fitness-Studio-Mitglieder, die ein Training in der vergangenen Woche, die Sie ausschließen möchten, die gelöscht workouts automatisch.

Erreicht wird dies durch eine ExpressionVisitor, dass gilt automatisch eine '.Where(e => !e."Gelöscht")' filter auf jeden IQueryable, die es finden kann in einem gegebenen Ausdruck.

Hier ist der 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);
    }
}

Ich bin vielleicht ein bisschen kurz auf Zeit, also werde ich wieder zu diesem Beitrag später mit mehr details, aber das wesentliche ist geschrieben und für diejenigen von Euch, begierig, alles zu versuchen; ich gebucht habe, das komplette test-Anwendung hier: https://github.com/amoerie/TestingGround

Allerdings könnte es noch einige Fehler, da dies sehr viel ein work in progress. Die konzeptionelle Idee ist der Ton aber, und ich erwarte, dass es voll funktionsfähig, bald habe ich einmal umgestaltet werden, dass alles ordentlich und die Zeit finden, zu schreiben, einige tests für diese.

Haben Sie als Ansichten verwenden, die in Ihrer Datenbank zu laden, Ihr problem zu Personen mit den gelöschten items ausgeschlossen?

Es bedeutet, müssen Sie gespeicherte Prozeduren verwenden, um anzeigen INSERT/UPDATE/DELETE Funktionalität, aber es wäre auf jeden Fall dein problem lösen, wenn Workout Karten zu einer Ansicht mit den gelöschten Zeilen weggelassen. Auch dies kann nicht die gleiche Arbeit in einem code-first-Ansatz...