Entity Framework Fluent API
Entity Framework Fluent API - Learn Entity Framework starting from Overview, Data annotations and the fluent API can be used together, but Code First gives .. In this case, to configure one-to-many relationship using Fluent API, you need . Feb 28, I've been reading Entity Framework Core in Action by Jon P Smith. If I want a property in my entity to be required, I can configure it with the Fluent API in nullable, Code First does not set cascade delete on the relationship. Jul 18, How to configure one to one relationships using the Fluent API in Entity Framework Core.
If you are only working with the foreign key, you can avoid this problem. Destination to be optional, meaning you could add a Lodging without a Destination.
This is because DestinationId is of type int, which is a value type and cannot be assigned null. By convention, Code First is using the nullability of the foreign key property in your class to determine if the relationship is required or optional. However, some of the confusing behaviors that developers encounter when working with related data in Entity Framework stems from dependent classes that do not have a foreign key property.PART 4 Entity relationship using entity framework code first approach one to one relation ship
The Entity Framework has certain rules that it follows when it checks relationship constraints, performs inserts, etc. This class has both a navigation property Accommodation and a foreign key property AccommodationId for the same relationship. Code First convention was not able to infer that AccommodationId is meant to be the foreign key. It simply found no properties that matched any of the three patterns that Code First convention uses to detect foreign key properties, and therefore created its own foreign key.
Fixing foreign key with Data Annotations You can configure foreign key properties using the ForeignKey annotation to clarify your intention to Code First.
Configure One-to-One Relationships using Fluent API in Entity Framework Core
Adding ForeignKey to the AccommodationId, along with information telling it which navigation property represents the relationship it is a foreign key for, will fix the problem: To specify the relationship, begin with the InternetSpecial entity.
Identifying the relationship to be configured modelBuilder. InternetSpecials What we want to change, however, is something about the foreign key that is also involved with this relationship.
Code First expects the foreign key property to be named LodgingId or one of the other conventional names.
So we need to tell it which property truly is the foreign key—AccommodationId. Specifying a foreign key property when it has an unconventional name modelBuilder. Working with Inverse Navigation Properties So far Code First has always been able to work out that the two navigation properties we have defined on each end of a relationship are in fact different ends of the same relationship. It has been able to do this because there has only ever been one possible match.
Configuring One To One Relationships In Entity Framework Core
For example, Lodging only contains a single property that refers to Destination Lodging. Destination ; likewise, Destination only contains a single property that references Lodging Destination.
You will need to provide some additional configuration. For example, what if you kept track of two contacts for each lodging? Go ahead and add these properties to the Lodging class: This will allow you to navigate from a Person to the Lodging instances that they are primary and secondary contact for.
Add the following two properties to the Person class: Because there are two sets of navigation properties, Code First is unable to work out how they match up. Too many foreign keys in the Lodgings table Code First convention can identify bidirectional relationships, but not when there are multiple bidirectional relationships between two entities.
You can place the annotations on either end of the relationship or both ends if you want. The InverseProperty Data Annotation needs the name of the corresponding navigation property in the related class as its parameter. PrimaryContact on one end and Person.
PrimaryContactFor on the other. Configuring multiple relationships fluently modelBuilder. SecondaryContactFor ; Working with Cascade Delete Cascade delete allows dependent data to be automatically deleted when the principal record is deleted.
If you delete a Destination, for example, the related Lodgings will also be deleted automatically. Entity Framework supports cascade delete behavior for in-memory data as well as in the database. As discussed in Chapter 19 of the second edition of Programming Entity Frameworkit is recommended that you implement cascade delete on entities in the model if their mapped database objects also have cascade delete defined.
By convention, Code First switches on cascade delete for required relationships. When a cascade delete is defined, Code First will also configure a cascade delete in the database that it creates. Earlier in this chapter we looked at making the Lodging to Destination relationship required.
Entity Framework - Fluent API
In other words, a Lodging cannot exist without a Destination. Therefore, if a Destination is deleted, any related Lodgings that are in memory and being change-tracked by the context will also be deleted.
When SaveChanges is called, the database will delete any related rows that remain in the Lodgings table, using its cascade delete behavior.
Looking at the database, you can see that Code First carried through the cascade delete and set up a constraint on the relationship in the database.
The code uses a context to insert a new Destination with a couple of Lodgings. It then saves these Lodgings to the database and records the primary of the new Destination. In a separate context, the code then retrieves the Destination and its related Lodgings, and then uses the Remove method to mark the Destination instance as Deleted.
WriteLine to inspect the state of one of the related Lodging instances that are in memory. The Entry method gives us access to the information that EF has about the state of a given object. Next, the call to SaveChanges persists the deletions to the database.
Add destination ; context. Remove destination ; Console. WriteLine "State of one Lodging: It is Deleted also even though we did not explicitly remove any of the Lodgings. The first two are to delete the related Lodging instances that were in memory and the third to delete the Destination. Remove destination ; context.
The database cascade delete will delete the related lodgings in response. When querying for the Lodgings at the end, since the database deleted the lodgings, the query will return no results and the lodgings variable will be an empty list. Turning On or Off Client-Side Cascade Delete with Fluent Configurations You might be working with an existing database that does not use cascade delete or you may have a policy of being explicit about data removal and not letting it happen automatically in the database.
But you may want a required relationship in your classes without leveraging cascade delete. For the scenarios where you want a required relationship but no cascade delete, you can explicitly override the convention and configure cascade delete behavior with the Fluent API. When you follow some simple rules on property types and names, Entity Framework will auto-configure many of the software and database features. Configuring Relationships in Entity Framework Configuring scalar non-relational properties is quite straightforward, but when it comes to entity relationships, it can be more tricky to decide which approach is best for configuring them.
By default, when I delete a Student, I will get a referential integrity error: So how do I fix this?
The official Microsoft documentation recommends manually deleting each foreign key for dependent entities: If we look at the documentation for Entity Framework 6 it says that: 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.
Entity Framework should now set the foreign keys to null for these entities when I delete a student. By using Fluent API Configurations Conventions for One-to-Many Relationships There are certain conventions in Entity Framework which if followed in entity classes domain classes will automatically result in a one-to-many relationship between two tables in the database. You don't need to configure anything else.
Let's look at an example of all the conventions which create a one-to-many relationship. Convention 1 We want to establish a one-to-many relationship between the Student and Grade entities where many students are associated with one Grade. It means that each Student entity points to a Grade. This can be achieved by including a reference navigation property of type Grade in the Student entity class, as shown below.
So, there can be many students in a single grade. Convention 2 Another convention is to include a collection navigation property in the principal entity as shown below.
This also results in a one-to-many relationship between the Student and Grade entities. This example produces the same result in the database as convention 1. Convention 3 Including navigation properties at both ends will also result in a one-to-many relationship, as shown below.