Want to get a better idea of how cascade deletes work in Entity Framework Code First scenarios? Want to see it in action? Stick with us as we quickly demystify what happens when you tell your data context to nuke a parent entity. This post is authored by Calgary .NET User Group Leader David Paquette with help from Microsoft MVP in Asp.Net James Chambers.

We got to spend a great week back in March at Prairie Dev Con West, chalk full of sessions, presentations, workshops, conversations and, of course, questions.  One of the questions that came up during my session: "How does Entity Framework Code First deal with cascading deletes?". James and I had different thoughts on what the default was, if it was different from SQL server, if it was the same as EF proper and if there was a way to override whatever the default was. 

So we built a set of examples and figured out that the answer is simple: it depends.  (Download Samples)

Consider the example of a hockey league. You have several different entities in the league including games, teams that play the games and players that make up the teams. Each team also has a mascot.  If you delete a team, we need a couple of things to happen:

1. The team, games and mascot will be deleted, and
2. The players for that team will remain in the league (and therefore the database) but they should no longer be assigned to a team.

So, let's make this start to come together with a look at the default behaviour in SQL when using an EDMX-driven project.

The Reference – Understanding EF's Behaviour with an EDMX/DB First Approach

First up let’s take a look at the DB first approach.  In the database, we defined 4 tables: Teams, Players, Mascots, and Games.  We also defined 4 foreign keys as follows:

Players.Team_Id (NULL) –> Teams.Id

Mascots.Id (NOT NULL) –> Teams.Id (ON DELETE CASCADE)

Games.HomeTeam_Id (NOT NULL) –> Teams.Id

Games.AwayTeam_Id (NOT NULL) –> Teams.Id

Note that by specifying ON DELETE CASCADE for the Mascots –> Teams foreign key, the database will automatically delete the team’s mascot when the team is deleted.  While we want the same behaviour for the Games –> Teams foreign keys, it is not possible to accomplish this using ON DELETE CASCADE in SQL Server.  Specifying a ON DELETE CASCADE on these foreign keys would cause a circular reference error:

The series of cascading referential actions triggered by a single DELETE or UPDATE must form a tree that contains no circular references. No table can appear more than one time in the list of all cascading referential actions that result from the DELETE or UPDATE – MSDN

When we create an entity data model from the above database, we get the following:

In order to get the Games to be deleted when the Team is deleted, we need to specify End1 OnDelete action of Cascade for the HomeGames and AwayGames associations.

Now, we have an Entity Data Model that accomplishes what we set out to do.  One caveat here is that Entity Framework will only properly handle the cascading delete when the the players and games for the team have been loaded into memory.  For a more detailed look at Cascade Delete in EF Database First, take a look at this blog post by Alex James.

Building The Same Sample with EF Code First

Next, we're going to build up the model with the code first approach.  EF Code First is defined on the Ado.Net team blog as such:

Code First allows you to define your model using C# or VB.Net classes, optionally additional configuration can be performed using attributes on your classes and properties or by using a Fluent API. Your model can be used to generate a database schema or to map to an existing database.

Entity Framework Code First follows some conventions to determine when to cascade delete on a relationship.  More details can be found on MSDN:

If a foreign key on the dependent entity is not nullable, then Code First sets cascade delete on the relationship. If a foreign key on the dependent entity is nullable, Code First does not set cascade delete on the relationship, and when the principal is deleted the foreign key will be set to null. The multiplicity and cascade delete behavior detected by convention can be overridden by using the fluent API. For more information, see Configuring Relationships with Fluent API (Code First).

Our DbContext consists of 4 DbSets:

public DbSet<Team> Teams { get; set; }
public DbSet<Player> Players { get; set; }
public DbSet<Mascot> Mascots { get; set; }
public DbSet<Game> Games { get; set; }

When we set the Mascot –> Team relationship to required, Entity Framework will automatically delete the Mascot when the Team is deleted.  This can be done either using the [Required] data annotation attribute, or by overriding the OnModelCreating method of your DbContext and using the fluent API.

Data Annotations:

public class Mascot
{
    public int Id { get; set; }
    public string Name { get; set; }

    [Required]
    public virtual Team Team { get; set; }
}

Fluent API:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Mascot>().HasRequired(m => m.Team);
}

The Player –> Team relationship is automatically handled by the Code First conventions. When a Team is deleted, the Team property for all the players on that team will be set to null.  No additional configuration is required, however all the Player entities must be loaded into memory for the cascading to work properly.

The Game –> Team relationship causes some grief in our Code First example.  If we try setting the HomeTeam and AwayTeam relationships to required, Entity Framework will attempt to set On Cascade Delete for the HomeTeam and AwayTeam foreign keys when creating the database tables.  As we saw in the database first example, this causes a circular reference error and throws the following SqlException:

Introducing FOREIGN KEY constraint 'FK_Games_Teams_AwayTeam_Id' on table 'Games' may cause cycles or multiple cascade paths. Specify ON DELETE NO ACTION or ON UPDATE NO ACTION, or modify other FOREIGN KEY constraints. Could not create constraint.

To solve this problem, we need to disable the default cascade delete behaviour using the fluent API:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Mascot>().HasRequired(m => m.Team);

    modelBuilder.Entity<Team>()
                        .HasMany(t => t.HomeGames)
                        .WithRequired(g => g.HomeTeam)
                        .WillCascadeOnDelete(false);

    modelBuilder.Entity<Team>()
                        .HasMany(t => t.AwayGames)
                        .WithRequired(g => g.AwayTeam)
                        .WillCascadeOnDelete(false);

    base.OnModelCreating(modelBuilder);
}

Unfortunately, this means we need to manually manage the cascade delete behaviour.  When a Team is deleted, we need to manually delete all the home and away Games for that Team.

foreach (Game awayGame in jets.AwayGames.ToArray())
{
    entities.Games.Remove(awayGame);
}

foreach (Game homeGame in homeGames)
{
    entities.Games.Remove(homeGame);
}

entities.Teams.Remove(jets);

entities.SaveChanges();

Overriding the Defaults – When and How To

As you have seen, the default behaviour of Entity Framework Code First can be overridden using the fluent API.  This can be done by overriding the OnModelCreating method of your DbContext, or by creating separate model override files for each entity.  More information is available on MSDN.

Going Further

These were simple examples but they helped us illustrate a couple of points. First of all, we were able to demonstrate the default behaviour of Entity Framework when dealing with cascading deletes, specifically how entity relationships affect the outcome. Secondly, we showed you how to modify the code and control the behaviour to get the outcome you're looking for.

Finally, we showed you how easy it is to explore this kind of thing, and we're hoping that you get a chance to experiment even further. For example, did you know that:

• Entity Framework Code First also works seamlessly with SQL Azure (MSDN)
• Database creation defaults can be overridden using a variety of IDatabaseInitializers  (Understanding Database Initializers)
• You can use Code Based migrations to manage database upgrades as your model continues to evolve (MSDN)

Next Steps

There's no time like the present to start the learning, so here's what you need to do:

1. Get up-to-date in Visual Studio 2010 (VS2010 | SP1) or Visual Studio 2012 (VS2012)
2. Build yourself a project to try these concepts out (or download the sample project)
3. Get into the community and ask questions! There are a ton of great resources out there and community members willing to help you out (like these two guys!).

Good luck!

About the Authors

David Paquette works as a lead developer at P2 Energy Solutions in Calgary, Alberta where he builds commercial software products for the energy industry.  Outside of work, David enjoys outdoor camping, fishing, and skiing. David is also active in the software community giving presentations both locally and at conferences. David also serves as the President of Calgary .Net User Group.

James Chambers crafts software awesomeness with an incredible team at LogiSense Corp, based in Cambridge, Ontario. A husband, father and humanitarian, he is currently residing in the province of Manitoba where he resists the urge to cheer for the Jets and maintains he allegiance to the Calgary Flames. When he's not active with the family, outdoors or volunteering, you can find James speaking at conferences and user groups across the country about web development and related technologies.