Interestingly enough, there is a lot of similarity in the approaches we used for updates and deletions. We can use a query to find data and then mark it for deletion by using the Remove method of DbSet. This approach actually has the same drawbacks as it does with the update, resulting in a select query in addition to the delete query. Nonetheless, let's take a look at how it is done:

using (var context = new Context())
{
    var toDelete = context.People.Find(personId);
    toDelete.Phones.ToList().ForEach(phone => context.Phones.Remove(phone));
    context.People.Remove(toDelete);
    context.SaveChanges();
}

This code deletes each child entity, phone in our case, and then deletes the root entity. You would have to know the primary key value for the entity you want to delete. The preceding code assumes that you have this value in the personId variable. In the case of a web application, this value will be submitted to the method that handles deletion. Alternatively, we could use the RemoveRange method to remove multiple entities in a single statement. Here is how the code looks in VB.NET:

Using context = New Context()
    Dim toDelete = context.People.Find(personId)
    toDelete.Phones.ToList().ForEach(Function(phone) context.Phones.Remove(phone))
    context.People.Remove(toDelete)
    context.SaveChanges()
End Using

There is one important difference between this code and the insert code. We have to manually delete each child record, by removing it from a corresponding collection. Code that is provided relies on lazy loading to work to populate the list of phones for a person. You can also rely on a cascade of delete operation instead, though some DBAs will frown at this practice.

Now, let's delete entities by setting a state on each entity. Again, we need to account for dependent entities. For example:

var toDeleteByState = new Person { PersonId = personId };
toDeleteByState.Phones.Add(new Phone
{
    PhoneId = phoneId1,
    PersonId = personId
});
toDeleteByState.Phones.Add(new Phone
{
    PhoneId = phoneId2,
    PersonId = personId
});

using (var context = new Context())
{
    context.People.Attach(toDeleteByState);
    foreach (var phone in toDeleteByState.Phones.ToList())
    {
        context.Entry(phone).State = EntityState.Deleted;
    }
    context.Entry(toDeleteByState).State = EntityState.Deleted;
    context.SaveChanges();
}

You undoubtedly noticed something very different from any other data manipulation. In order to delete a person, we only need to set the primary key property and nothing else. For phones, we just needed to set the primary key property and parent identifier property. In the case of web applications, you need to submit all the identifiers, or you will need to resort to requerying child data to find the identifiers. Here is how this code looks in VB.NET:

Dim toDeleteByState = New Person With { .PersonId = personId }
toDeleteByState.Phones.Add(New Phone With {.PhoneId = phoneId1, .PersonId = personId })
toDeleteByState.Phones.Add(New Phone With {.PhoneId = phoneId2, .PersonId = personId })
        
Using context = New Context()
    context.People.Attach(toDeleteByState)
    For Each phone In toDeleteByState.Phones.ToList()
        context.Entry(phone).State = EntityState.Deleted
    Next
    context.Entry(toDeleteByState).State = EntityState.Deleted
    context.SaveChanges()
End Using

You can submit full entities for deletion as well. If you are sticking to strict guidelines for deletion for REST web services, those define that only an identifier should be submitted with a web request. So, you will need to decide for yourself which of the two approaches works better for your specific circumstances.

var localQuery = context.People.Local.Where(p => p.LastName.Contains("o")).ToList();

Dim localQuery = context.People.Local.Where(Function(p) p.LastName.Contains("o")).ToList()

var query = context.People.ToList();
var findQuery = context.People.Find(1);

Dim query = context.People.ToList()
Dim findQuery = context.People.Find(1)

foreach (var dbEntityEntry in context.ChangeTracker.Entries<Person>())
{
    Console.WriteLine(dbEntityEntry.State);
    Console.WriteLine(dbEntityEntry.Entity.LastName);
}

For Each dbEntityEntry In context.ChangeTracker.Entries(Of Person)
    Console.WriteLine(dbEntityEntry.State)
    Console.WriteLine(dbEntityEntry.Entity.LastName)
Next