在 EF Core 中设置预定义条件

Question

Assume

// connection strings and other configurations is not mentioned for simplicity
MyDbContext context = new MyDbContext();
Var Entities = Context.Set< table1>();
Var list = Entities.ToList();

LINQ to SQL generates the following SQL query:

Select col0, col1, isdeleted, coln  
From table1

This code is perfect and return a list of table1 objects (suppose 20 rows).

My requirement is:

// looking for a function or anything. This is my need
Entities.AddDefaultFilter("isdeleted", false);

// expected rows (18 rows, 2 rows have isdeleted = true) 
// Those should be excluded 
Var list = Entities.ToList();

I achieved this in a very poor way:

var list = Entities.ToList();

return list.Where(x => ((bool?)x.GetType().GetProperty("IsDeleted").GetValue(x)) == false).ToList(); 

This code is perfect and return only those rows that meet the condition isdeleted = false .

This is poor because first it loads all rows from the database, then filters / removes the rows which have isdeleted = true value.

If table1 has 1M rows and 300K rows with isdeleted = true then it takes extra time and memory.

Sorry for bad grammar.

Thank you.

Answer 1

I'm not that familiar with EF Core but if it works in a similar way to EF6 then when you call.ToList() on a DbSet it will effectively do the equivalent of a SQL Select * on the table/entity.

So by doing

var list = Entities.ToList();

You are returning all records for that entity into memory. This then filters the in memory data:

return list.Where(x => ((bool?)x.GetType().GetProperty("IsDeleted").GetValue(x)) == false).ToList();

If you were to do something like:

return Entities.Where(x => !x.IsDeleted).ToList()

The SQL generated would include the where clause and be much more efficient.

Updated 04/05/2020:

To include a filter for a generic type you could build an expression and pass that into the LINQ statement:

var props = typeof(TEntity).GetProperties();

if (props.Any(p => p.Name == "IsDeleted"))
{
    ParameterExpression pe = Expression.Parameter(typeof(TEntity), "x");

    ConstantExpression valExpression = Expression.Constant(true, typeof(bool));
    MemberExpression member = Expression.Property(pe, "IsDeleted");
    Expression predicateBody = Expression.Equal(member, valExpression);

    var final = Expression.Lambda<Func<TEntity, bool>>(body: predicateBody, parameters: pe);

    return Entities.Where(final.Compile()).ToList();
}
else
{
   return Entities.ToList();
}

If all of your entities include the "IsDeleted" property then the check to see if it exists could be removed. Code hasn't been tested but should be along the right lines.

Answer 2

Instead of getting the entire list first, could you not use the where predicate to filter the results before going to the server:

return Entities.Where(x => x.IsDeleted==false).ToList();

or even simpler:

return Entities.Where(x => !x.IsDeleted).ToList();

The important point here is the ToList() at the end of the statement. It should then output the SQL as follows:

Select col0,col1, isdeleted, coln from table1 WHERE isdeleted=0

Answer 3

This code is copied from @PeterG's code and bit modified:

 var props = typeof(T).GetProperties();
                if (props.Any(p => p.Name == "IsDeleted"))
                {
                    ConstantExpression valExpression = Expression.Constant(false, typeof(bool));//true to false
                    ParameterExpression pe = Expression.Parameter(typeof(T), "x");//this line was moved
                    MemberExpression member = Expression.Property(pe, "IsDeleted");
                    Expression predicateBody = Expression.Equal(member, valExpression);
                    var final = Expression.Lambda<Func<T, bool>>(body: predicateBody, parameters: pe);                

                    //var iq =(IQueryable<T>) Entities.Where(final.Compile());
                    //var sql = EfExtensions.ToSql(iq);
                    var list2 = Entities.Where(final.Compile()).ToList();//this the main expectation.
                    return list2 ;
                }
                else
                {//I keep my old code  if i ever need.
                    var list= Entities.ToList();
                    return list.Where(x => ((bool?)x.GetType().GetProperty("IsDeleted").GetValue(x)) != true).ToList();
                }

All credit goes to PeterG. Thanks man. https://stackoverflow.com/users/10070561/peterg