实体框架：WillCascadeOnDelete 和 Include

Question

I got a database model like this:

class User
{
    public int ID { get; set; }
    public string Username { get; set; }
    public virtual ICollection<Order> Orders { get; set; }
}
class Order
{
    public int ID { get; set; }
    public string OrderName { get; set; }
    public virtual User User { get; set; }
}

My modelBuilder configurations looks like this:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<User>().ToTable("Users", "dbo");
    modelBuilder.Entity<User>().HasKey(x => x.ID);
    modelBuilder.Entity<User>().Property(x => x.Username).IsRequired();
    modelBuilder.Entity<User>().HasMany(x => x.Orders).WithRequired(x => x.User).WillCascadeOnDelete(true);

    modelBuilder.Entity<Order>().ToTable("Orders", "dbo");
    modelBuilder.Entity<Order>().HasKey(x => x.ID);
    modelBuilder.Entity<Order>().Property(x => x.OrderName).IsRequired();
    modelBuilder.Entity<Order>().Property(x => x.UserID).IsRequired();
}

The sql for table dbo.Orders looks like:

CREATE TABLE dbo.Orders (
    ID int NOT NULL PRIMARY KEY IDENTITY(1, 1),
    OrderName nvarchar(256) NOT NULL,
    UserID int NOT NULL,

    CONSTRAINT FK_Orders_Users FOREIGN KEY (UserID) REFERENCES dbo.Users (ID) ON DELETE CASCADE
);

I can see in sql server profiler that when im executing:

dbContext.Users.Remove(dbContext.Users.Include(x => x.Orders).First(x => x.ID == 1));

EF is deleting all orders seperatly before it's deleting the user. I thought that EF rely on ON DELETE CASCADE specified in SQL server foreign key when setting WillCascadeOnDelete(true) (which is the default behaviour for relationships in EF).

Why EF acts like this and how can I tell EF that it's not needed to remove the Order s before removing the User ?

Answer 1

You can remove these cascade delete conventions by using:

//Remove cascade delete conventions 
modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();

■ In the above example, EF appllies a set of conventions (convention applies to all your entities) when building the model, and you can override the conventions with the fluent configuration or attributes as shown below:

■ The following code configures the relationship to be required and then disables cascade delete (only for the related entity):

modelBuilder.Entity<Course>()
    .HasRequired(t => t.Department)
    .WithMany(t => t.Courses)
    .HasForeignKey(d => d.DepartmentId)
    .WillCascadeOnDelete(false);

Update: If you have FK related data that to be affected by this convemtion, then you could use Nullable FK as shown below. The above code snippet will create a nullable DepartmentId column in the database because we have used Nullable<int> type ( ? is a shortcut for Nullable<int> ).

public int? DepartmentId { get; set; }

Hope this helps.

Answer 2

If you have the dependent entities loaded in the change tracker, then EF will apply the cascading behavior in SaveChanges().

The delete behavior configured in the EF Core model is only applied when the principal entity is deleted using EF Core and the dependent entities are loaded in memory (that is, for tracked dependents). A corresponding cascade behavior needs to be setup in the database to ensure data that is not being tracked by the context has the necessary action applied. If you use EF Core to create the database, this cascade behavior will be setup for you.

https://docs.microsoft.com/en-us/ef/core/saving/cascade-delete#delete-behaviors

If you don't want that, then don't fetch the orders. Instead just new-up a stub user and delete it.

var stubUser = new User() {ID = 1};
dbContext.Users.Remove(stubUser);
dbContext.SaveChanges();