Logical Delete on EntityFramework - entity-framework

Question

What is the elegant way of the soft delete on EntityFramework? I have already identified a property (database field) as deleted and always use this filter on linq statements.
Like
Foo Class
int NumberField
string Description
bool Deleted
contexts.Foos.Where(x=> !x.Deleted);
It is not feasible on complex queries.
I just looked these solutions..
Link 1, Link 2
Any help appreciated..

Answer 1

Yes this possible with EF via pattern.
If you use a Fascade/repository pattern and access EVERY time via that fascade.
eg
an implementation of an interface on ALL repository classes might look like this:
class MyRepositoryBase<T>....
public IQueryable<T> ValidQuerySet // this is not deleted check Set
{ get { return Context.Set<T>().Where(t => t.deleted != true);
}
}
You would access exactly as if it was the original DbSet.
EF will combine the conditions.
var myQuerySet = MyRespository<T>.ValidQuerySet.Where(t=>t.foo == "bar");

Answer 2

Instead of directly querying your context you might want to consider creating repositories over the context class itself (like found on this site). What you'll be able to do then is whenever you're querying for records (such as by using the Filter<T>(Expression<Func<T, bool>> predicate) method of the repository you can always do the following:
return Context.Set<Foo>().Where<Foo>(x => !x.Deleted).Where<Foo>(predicate).AsQueryable<Foo>();
What would be even better is if you were to implement that soft delete in more than one object type and then pull that into an abstract class (call it SoftDeleteable, for example), and so then your Filter method signature could be:
public virtual IQueryable<T> Filter<T>(Expression<Func<T, bool>> predicate) where T : SoftDeletable

Answer 3

You probably not going to like my answer, but the "less painful" way I can think of needs lots of Stored Procedures: 1 per each Entity, whereas all you do is if exists UPDATE foo Deleted = True. Mine usually look like this
PROCEDURE [dbo].[SP_Address_UnSet]
#ID bigint
AS
BEGIN
DECLARE #IsInactive bit
SELECT #IsInactive = IsInactive
FROM [Address]
WHERE AddressID = #ID
IF (0 = ##ROWCOUNT)
RETURN -1
-- implicit else
IF (1 = #IsInactive)
RETURN 0
-- implicit else
UPDATE [Address]
SET IsInactive = 1
WHERE AddressID = #ID
RETURN ##ROWCOUNT -- should be 1
END
Then on each entity map to that SP.
You COULD have 1 single SP, and pass the table name as a param, but since you can't use it directly in T-SQL via dynamic query, you would have to build sub executions (and worry avout SQL injection!!)
Exec('SELECT * FROM ' + #tableName)

Answer 4

Global Query Filters (EF Core) and Entity Framework Interceptors (EF 6+) are new features that added on EntityFramework in order to use on this kind of problems.

Answer 5

I find it's very painful to do "soft delete" this way:
you have to remember this flag everywhere when you do data access.
Yes, you can wrap it around some repository patter, but you still
have it everywhere.
Your table is quickly filled with "deleted"
entries, and make reporting, analysis not efficient.
I will suggest you just put hard "Deleted" entries into different table or databases, it will save you time in long run.