了解使用流利的 api 禁用级联删除

Question

I am new to asp.net and I am following a course where we added this piece of code to disable oncascade delete from related table using the below code:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Attendance>()
        .HasRequired(a => a.Gig)
        .WithMany()
        .WillCascadeOnDelete(false);
        
    base.OnModelCreating(modelBuilder);
}

I want to understand many parts:

1. why we define entity method with attendance type,based on my understanding this type should be used when creating the method to specify the returned values not when calling the method.

2. what does HasRequired mean and what does withmany means?

Answer 1

On cascade delete

Let's say there is another type link to your attendance. So in database this other type (table) will have a foreign key to the Attendance table.

If you try to delete an Attendance record in the datatable, it will fail if this record is used in the other table.

With the cascade delete it will delete all related records besides the Attendance record.

If the cascade delete is not enable the deletion will fail because other records need this Attendance record.

Entity

No matter if you generate the database from your code or if the database already exists, your C# class representing the table cannot provide all information (for example if you do not follow the convention, EF cannot know which field is the primary key, which field is not nullable (see next point), or if the table name will match the class name).

With the modelBuilder.Entity<Attendance>() you will help EF to build his "inner model of how the database will looks like". In this case you provide to EF additional information about the "Attendance" type.

So you could warn EF this table is in another schema or the table name is different...

Potentially you could do that for all your entities/tables.

IsRequired (not used in your example but I confond IsRequired and HasRequired so I let the explanation here)

The IsRequired is used with nullable types. In database you can have a type "varchar(x) not null" and in C# it will be a "string". But string can be nullable in C# so the HasRequired is a configuration that will tell your ORM "Yes the type is nullable but in my configuration it should not be the case".

So when EF will generate the database the type will be "not null" or when your EF will validate the entity before calling the database, that check will be done.

HasRequired

It's the same concept as the IsRequired but a little more complex since it's used when there is multiple tables involved. For example Contract and Customer, a contract is owned by one customer but a customer can have multiple contracts. So in the database Contract table will have a foreign key to Customer and in the class Contract will have a (navigation) property named Customer.

public class Contract 
{
    public Customer Customer { get; set; }
}

public class Customer
{       
}

modelBuilder.Entity<Contract>()
    .HasRequired(c => c.Customer)

This configuration will indicate Contract have a navigation property to Customer and this is a required one meaning the foreign key cannot be null. If you want it to be nullable you should use HasOptional .

WithMany Now you configured the HasRequired, you have the WithMany. This one will indicate you can have multiple Contract for a Customer (Contract has a required Customer who have many Contracts: It's a "one to many" relationship). But it also indicates the Customer does not care about the contracts:

public class Customer
{       
}

Here you can see the Customer class does not have a (navigation) property to the contracts. If you don't need the Customer object to be able to reach the contracts this is perfectly fine.

Now if you want to have that ability you will need to do this:

public class Customer
{
   public List<Contract> Contracts { get; set; }       
}

modelBuilder.Entity<Contract>()
    .HasRequired(c => c.Customer)
    .WithMany(cu => cu.Contracts)

In that case you indicate Contract have a relationship required to Customer and this relation from the Customer object point of view lead to "Contracts" property.