Filtrar todas las propiedades de navegación antes de cargarlas (perezosas o ansiosas) en la memoria

Después de mucha investigación, finalmente he encontrado una manera de lograr lo que quería. La esencia de esto es que intercepto entidades materializadas con un controlador de eventos en el contexto del objeto, y luego inyecto mi clase de colección personalizada en cada propiedad de colección que puedo encontrar (con reflexión).

La parte más importante es interceptar la "DbCollectionEntry", la clase responsable de cargar propiedades de colección relacionadas. Al moverme entre la entidad y el DbCollectionEntry, me obtenga un control total sobre lo que se carga, cuándo y cómo. El único inconveniente es que esta clase DbCollectionEntry tiene poco o ningún miembro público, lo que requiere que use reflexión para manipularlo.

Aquí está mi clase de colección personalizada que implementa ICollection y contiene una referencia al DbCollectionEntry apropiado:

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 lo hojea, encontrará que la parte más importante es la propiedad "Entities", que cargará perezosamente los valores reales. En el constructor de FilteredCollection Paso una ICollection opcional para los escenarios donde la colección ya está cargada con entusiasmo.

Por supuesto, todavía necesitamos configurar Entity Framework para que nuestra FilteredCollection se use en todas partes donde haya propiedades de colección. Esto se puede lograr conectándose al evento ObjectMaterialized del ObjectContext subyacente de 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 });
            }
        }
    };

Todo parece bastante complicado, pero lo que hace esencialmente es escanear el tipo materializado para las propiedades de la colección y cambiar el valor a una colección filtrada. También pasa el DbCollectionEntry a la colección filtrada para que pueda hacer su magia.

Esto cubre toda la parte de "entidades de carga". El único inconveniente hasta ahora es que las propiedades de colección cargadas con entusiasmo aún incluirán las entidades eliminadas, pero se filtran en el método 'Add' de la clase FilterCollection. Este es un inconveniente aceptable, aunque todavía tengo que hacer algunas pruebas sobre cómo esto afecta al método SaveChanges ().

Por supuesto, esto todavía deja un problema: no hay filtrado automático en las consultas. Si desea buscar a los miembros del gimnasio que hicieron un entrenamiento en la semana pasada, desea excluir los entrenamientos eliminados automáticamente.

Esto se logra a través de un Expresionvisitor que aplica automáticamente un '.Donde(e => !e. Deleted)' filtrar a cada IQueryable que puede encontrar en una expresión dada.

Aquí está el código:

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

Yo soy se está quedando un poco corto de tiempo, así que volveré a este post más tarde con más detalles, pero la esencia está escrita y para aquellos de ustedes ansiosos por probarlo todo; he publicado la aplicación de prueba completa aquí: https://github.com/amoerie/TestingGround

Sin embargo, todavía puede haber algunos errores, ya que esto es mucho un trabajo en progreso. Sin embargo, la idea conceptual es sólida, y espero que funcione completamente pronto una vez que haya refactorizado todo cuidadosamente y encuentre el tiempo para escribe algunas pruebas para esto.