To see all the basic instructions and complete navigation for this series, visit Entity Framework Core with ASP.NET Core Tutorial.<\/a><\/p>\n Before we start modifying data with Entity Framework Core, we have to be familiar with some additional EF Core features.<\/p>\n As we learned, in the first part of the series<\/a>, DbContext consists of only three properties: ChangeTracker, Database, and Model. We have seen the Model and Database properties in action in previous articles, so in this article, we are going to talk about the ChangeTracker and State properties.<\/p>\n The ChangeTracker property provides access to change tracking information and operations about the currently loaded entity. This ability is very important when we want to execute any of the database modification operations. EF Core has this kind of information(about tracking and operations) whether we create, modify it or delete an entity.<\/p>\n Furthermore, EF Core won\u2019t execute any operation until we call the SaveChanges method. So knowing what operation we want to execute is crucial to EF Core prior to calling the SaveChanges method.<\/p>\n Every tracked entity has the State property attached to it. When we use the context object to load an entity without the Here are the possible states of tracked entities:<\/p>\n Now, when we know all this stuff, we can continue towards the Create, Update and Delete operations.<\/p>\n We can create new rows in the database by using the Add and AddRange methods. The Add method will modify the State of the single entity where the AddRange can do the same but for the multiple entities. Let\u2019s see the Add method in action after we send the student object from Postman:<\/p>\n In this action, we use the HttpPost attribute to mark it as a POST action. Additionally, we load the student entity with the FromBody attribute and add two validation checks in our code.<\/p>\n All of these are ASP.NET Core related, so if you are not familiar with these concepts we strongly suggest visiting the ASP.NET Core Web API \u2013 Post, Put, Delete<\/a> article. This article will also help you if you are not familiar with the process of sending the POST requests from Postman.<\/p>\n After these checks, we call the This is the result in the database:<\/p>\n If we modify our code slightly, we can inspect the way that the entity\u2019s state is changed during this action. Of course, the additional code is not required to save the entity to the database, it is here just for learning purposes:<\/p>\n As we can see, before we add our entity to the db it has the When we want to add multiple rows in the database, we use the Another important thing to mention here is that the Now we are going to learn how to include relationships while adding the main entity to the database. To demonstrate that, we are going to modify our first example a bit:<\/p>\n As we can see from the code above, we are only adding the And we can check the response from the application:<\/p>\n It is important to notice that we are not adding Id value manually for any entity, EF Core is in charge of that. You can see in the database that the GUID values have been generated.<\/p>\n Excellent. We can do the same thing with one-to-many or many-to-many relationships.<\/p>\n There are two ways to update rows in the database. With Connected Update and with Disconnected Update. The difference is that with the connected update we use the same context object to load and modify entity. With the disconnected update, this is not the case. Either we use different context objects or we receive an object from a client that has all the properties as the entity in db, so we can update it without loading action first.<\/p>\n While working with the connected update there are three main steps to execute:<\/p>\n In the following examples, we are going to leave out the additional validations checks (for the sake of simplicity) because the validation is related to ASP.NET Core and you can read more about that in the ASP.NET Core Web API \u2013 Post, Put, Delete<\/a> article. <\/em><\/p>\n So, let\u2019s see the connected update in action when we send the student object from a client with the We can see all three steps in the code above. We load the student object based on its id, then map the properties from the client\u2019s updated student, which sets the state of the entity to the EF Core, on the other hand, has the information on what exactly has been modified.<\/p>\n When we load our entity, EF Core starts tracking it and at that point the State is Once we send a request to this PUT action, the student\u2019s name is going to be updated:<\/p>\n We can see that only the Name property has been updated. If you can’t see both commands in the console window, you can find them in the Output window inside Visual Studio for sure.<\/p>\n When we have an entity that is already in the The result is pretty self-explanatory here.<\/p>\n Adding relationships to the update operations in EF Core is pretty easy. We can attach a relational entity to the main entity, modify it and EF Core will do the rest for us as soon as we call the Let\u2019s see how to update the relationship in EF Core:<\/p>\n When we send our request form Postman we are going to update the The same process applies to other relationship types.<\/p>\n The important thing to know is when we update our main entity by adding a new relationship entity, EF Core is going to create a new row in the relationship table and connects it to the main entity with a foreign key:<\/p>\n Since now we know how to update relationships in EF Core, we can continue on to the disconnected update.<\/p>\n There are several ways to execute a disconnected update, and we are going to show you two ways of doing that. In the first example, we are going to attach the object sent from a client, modify its state and then save it to the database:<\/p>\n The This also means that as of this moment, EF Core starts tracking the entity. Now, we are going to change the state to This is the object sent from the client:<\/p>\n And as you can see it has the Another way of doing the same thing is by using the We can see the difference. The There we go.<\/p>\n Now we know how to execute a disconnected update and what is the difference from a connected update.<\/p>\n The last way to modify data is by using delete actions. We have two ways of deleting rows and we are going to cover them both.<\/p>\n So, let\u2019s start with the Soft Delete approach.<\/p>\n With the Soft Delete approach, the entity is hidden rather than deleted. This is not an unusual way of doing delete actions because in many real-world projects we don\u2019t want to really delete any row because they will be required for some statistics later on.<\/p>\n So basically, we are not deleting an entity we are updating it by modifying its property (we are going to name it Deleted) to true.<\/p>\n To show how soft delete works, we need to make some changes in our current database model. To start, let\u2019s modify the Now, let\u2019s modify the The To apply these changes to the database, we are going to create and apply migration:<\/p>\n After this migration, all the rows in the To continue on, let\u2019s create additional Delete action in the controller and send the Delete request:<\/p>\n The soft delete consists of three parts:<\/p>\n This is the result in the database:<\/p>\n With the EF Core would usually return all the students from the Student table. But with the We can confirm that the \u201cStudent updated 3\u201d is missing, which is the only one with the Deleted property set to true.<\/p>\n Of course, if we want to ignore our query filter we can do that by applying the This query will include the \u201cdeleted\u201d entity:<\/p>\n Great job. Let\u2019s continue with the regular Delete.<\/p>\n In the regular delete, we are not modifying our entity but actually removing it from the database by using the There are three steps for this action as well:<\/p>\n We must be careful with Delete actions if our entity has relationships and we haven\u2019t specified them in the delete action. Deleting the main entity could delete the relationships as well (cascade delete), depending on the entity configuration.<\/p>\n We have talked about configuring delete actions in the Entity Framework Core Relationships<\/a> article.<\/p>\n This is the translated SQL command:<\/p>\nChangeTracker and State of the Entity in Entity Framework Core<\/span><\/h2>\n
AsNoTracking<\/code> method or we change its state via the Update, Remove or Add methods, that entity will be the tracked entity. The value of the State property can be obtained with the _context.Entry(our_entity).State<\/code> command.<\/p>\n\n
Creating Rows \u2013 Modifying Data with Add and AddRange methods<\/h2>\n
[HttpPost]\r\npublic IActionResult Post([FromBody] Student student)\r\n{\r\n if (student == null)\r\n return BadRequest();\r\n\r\n if (!ModelState.IsValid)\r\n return BadRequest();\r\n\r\n _context.Add(student);\r\n _context.SaveChanges();\r\n\r\n return Created(\"URI of the created entity\", student);\r\n}\r\n<\/pre>\nAdd<\/code> method to change the state of the entity to Added and call the SaveChanges<\/code> method to create a new row in the database. The last line of code will return the created entity (with its id) to the client:<\/p>\n![\"New](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/31-Returned-entity-after-adding.png\")
<\/a><\/p>\n![\"Database](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/32-Created-entity-in-db.png\")
<\/a><\/p>\nTracking Changes when Adding an Entity<\/h3>\n
[HttpPost]\r\npublic IActionResult Post([FromBody] Student student)\r\n{\r\n if (student == null)\r\n return BadRequest();\r\n\r\n if (!ModelState.IsValid)\r\n return BadRequest();\r\n\r\n var stateBeforeAdd = _context.Entry(student).State;\r\n\r\n _context.Add(student);\r\n\r\n var stateAfterAdd = _context.Entry(student).State;\r\n\r\n _context.SaveChanges();\r\n\r\n var stateAfterSaveChanges = _context.Entry(student).State;\r\n\r\n return Created("URI of the created entity", student);\r\n}\r\n<\/pre><\/p>\n![\"state](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/33-States-for-Add-method.png\")
<\/a><\/p>\nDetached<\/code> state. As soon as we use the Add<\/code> method, it has the Added<\/code> state. Finally, after the SaveChanges<\/code> method, it has the Unchanged<\/code> state.<\/p>\nUsing the AddRange Method<\/h3>\n
AddRange<\/code> method. It is the same procedure just a different method:<\/p>\n[HttpPost(\"postrange\")]\r\npublic IActionResult PostRange([FromBody] IEnumerable<Student> students)\r\n{\r\n \/\/additional checks\r\n\r\n _context.AddRange(students);\r\n _context.SaveChanges();\r\n\r\n return Created(\"URI is going here\", students);\r\n}\r\n<\/pre>\nSaveChanges<\/code> method executes the required operation but it also returns the number of affected rows. So if we need to check how many rows are affected by our operation, we can always return the result of the SaveChanges method:<\/p>\nvar result = _context.SaveChanges();<\/code><\/p>\nAdding Related Entities to the Database<\/h2>\n
[HttpPost]\r\npublic IActionResult Post([FromBody] Student student)\r\n{\r\n \/\/validation code goes here\r\n\r\n student.StudentDetails = new StudentDetails\r\n {\r\n Address = "Added Address",\r\n AdditionalInformation = "Additional information added"\r\n };\r\n\r\n _context.Add(student);\r\n _context.SaveChanges();\r\n\r\n return Created("URI of the created entity", student);\r\n}\r\n<\/pre><\/p>\nstudent<\/code> object to the application\u2019s context object but the studentDetails<\/code> object is also added to the database:<\/p>\n![\"Add](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/34-Add-method-with-relationship.png\")
<\/a><\/p>\n![\"response](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/35-Add-method-with-relationship-response.png\")
<\/a><\/p>\nUpdating Rows in the Database<\/h2>\n
\n
Name<\/code> property updated:<\/p>\n[HttpPut(\"{id}\")]\r\npublic IActionResult PUT (Guid id, [FromBody] Student student)\r\n{\r\n var dbStudent = _context.Students\r\n .FirstOrDefault(s => s.Id.Equals(id));\r\n\r\n dbStudent.Age = student.Age;\r\n dbStudent.Name = student.Name;\r\n dbStudent.IsRegularStudent = student.IsRegularStudent;\r\n\r\n _context.SaveChanges();\r\n\r\n return NoContent();\r\n}\r\n<\/pre>\nModified<\/code> and finally, we call SaveChanges<\/code>. Even though we have changed only the Name<\/code> property, we have to map all the properties because we don\u2019t know what has been modified on the client-side exactly.<\/p>\nUnchanged<\/code>. Once we modify any property from a loaded entity it changes the State<\/code> to Modified<\/code>. Finally, after the SaveChanges<\/code> method, the State is reverted to Unchanged<\/code>.<\/p>\n![\"Update](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/36-Update-actions-connected.png\")
<\/a><\/p>\nIsModified Property<\/h3>\n
Modified<\/code> state, EF Core uses another property that provides information about what really changed. This is the IsModified<\/code> property and we can examine how it works by slightly modifying our code:<\/p>\n[HttpPut("{id}")]\r\npublic IActionResult PUT (Guid id, [FromBody] Student student)\r\n{\r\n var dbStudent = _context.Students\r\n .FirstOrDefault(s => s.Id.Equals(id));\r\n\r\n dbStudent.Age = student.Age;\r\n dbStudent.Name = student.Name;\r\n dbStudent.IsRegularStudent = student.IsRegularStudent;\r\n\r\n var isAgeModified = _context.Entry(dbStudent).Property("Age").IsModified;\r\n var isNameModified = _context.Entry(dbStudent).Property("Name").IsModified;\r\n var isIsRegularStudentModified = _context.Entry(dbStudent).Property("IsRegularStudent").IsModified;\r\n\r\n _context.SaveChanges();\r\n\r\n return NoContent()\r\n}\r\n<\/pre><\/p>\n![\"IsModified](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/37-IsModified-property.png\")
<\/a><\/p>\nUpdating Relationships in EF Core<\/span><\/h2>\n
SaveChanges<\/code> method. The procedure is the same as we did it for the create actions.<\/p>\n[HttpPut(\"{id}\/relationship\")]\r\npublic IActionResult UpdateRelationship(Guid id, [FromBody] Student student)\r\n{\r\n var dbStudent = _context.Students\r\n .Include(s => s.StudentDetails)\r\n .FirstOrDefault(s => s.Id.Equals(id));\r\n\r\n dbStudent.Age = student.Age;\r\n dbStudent.Name = student.Name;\r\n dbStudent.IsRegularStudent = student.IsRegularStudent;\r\n dbStudent.StudentDetails.AdditionalInformation = \"Additional information updated\";\r\n\r\n _context.SaveChanges();\r\n\r\n return NoContent();\r\n}\r\n<\/pre>\nstudent<\/code> entity and the studentDetails<\/code> entity:<\/p>\n![\"Update](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/39-Update-relationships-sql-result.png\")
<\/a><\/p>\n[HttpPut(\"{id}\/relationship\")]\r\npublic IActionResult UpdateRelationhip(Guid id, [FromBody] Student student)\r\n{\r\n var dbStudent = _context.Students\r\n .FirstOrDefault(s => s.Id.Equals(id));\r\n\r\n dbStudent.StudentDetails = new StudentDetails\r\n {\r\n Id = new Guid(\"e2a3c45d-d19a-4603-b983-7f63e2b86f14\"),\r\n Address = \"added address\",\r\n AdditionalInformation = \"Additional information for student 2\"\r\n };\r\n\r\n _context.SaveChanges();\r\n\r\n return NoContent();\r\n}\r\n<\/pre>\n![\"Update](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/40-Update-relationships-sql-result-for-insert.png\")
<\/a><\/p>\nDisconnected Update in EF Core<\/span><\/h2>\n
[HttpPut(\"disconnected\")]\r\npublic IActionResult UpdateDisconnected([FromBody] Student student)\r\n{\r\n _context.Students.Attach(student);\r\n _context.Entry(student).State = EntityState.Modified;\r\n\r\n _context.SaveChanges();\r\n\r\n return NoContent();\r\n}\r\n<\/pre>\nstudent<\/code> object sent from the client has a Detached<\/code> state at a beginning. After we use the Attach<\/code> method the object is going to change state to Unchanged<\/code>.<\/p>\nModified<\/code> and save it to the database.<\/p>\n{\r\n "id": "DF75D335-A0EA-4798-8D8E-D7BF940F4D1D",\r\n "name": "Student updated 3",\r\n "age": "22",\r\n "isRegularStudent": false\r\n}\r\n<\/pre><\/p>\nId<\/code> property as well. Additionally, we have changed the Name<\/code> and IsRegularStudent<\/code> properties, but EF Core will update the entire object in the database.<\/p>\nUpdate<\/code> or UpdateRange<\/code> method if we have multiple objects ready for an update. So let\u2019s send the same object with only the IsRegularStudent<\/code> property modified to true:<\/p>\n[HttpPut(\"disconnected\")]\r\npublic IActionResult UpdateDisconnected([FromBody] Student student)\r\n{\r\n _context.Update(student);\r\n\r\n _context.SaveChanges();\r\n\r\n return NoContent();\r\n}\r\n<\/pre>\nUpdate<\/code> method will set the entity to tracked and also modify its state from Detached<\/code> to Modified<\/code>. So, we don\u2019t have to attach the entity and to modify its state explicitly because the Update<\/code> method does that for us. This approach is also going to update the entire object even though we changed just one property:<\/p>\n![\"Disconnected](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/41-Disconnected-update-command.png\")
<\/a><\/p>\nDelete Operations in EF Core<\/span><\/h2>\n
Soft Delete in Entity Framework Core<\/span><\/h3>\n
Student<\/code> model by adding additional property:<\/p>\npublic bool Deleted { get; set; }<\/pre>\nStudentConfiguration<\/code> class, by adding an additional method to filter out all the Deleted students from the queries:<\/p>\nbuilder.HasQueryFilter(s => !s.Deleted);<\/pre>\n
HasQueryFilter<\/code> method will include only those Student<\/code> entities with the Deleted<\/code> property set to false. Or in other words, it will ignore all the students with Deleted set to true.<\/p>\nPM> Add-Migration AddedDeletedPropertyToStudent\r\nPM> Update-Database\r\n<\/pre>\n
Student<\/code> table will have the Deleted<\/code> column set to zero (false).<\/p>\n[HttpDelete(\"{id}\")]\r\npublic IActionResult Delete(Guid id)\r\n{\r\n var student = _context.Students\r\n .FirstOrDefault(s => s.Id.Equals(id));\r\n\r\n if (student == null)\r\n return BadRequest();\r\n\r\n student.Deleted = true;\r\n _context.SaveChanges();\r\n\r\n return NoContent();\r\n}\r\n<\/pre>\n\n
![\"Soft](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/42-Soft-delete-sql-result.png\")
<\/a><\/p>\nLoading Data with QueryFilter implemented and Ignoring QueryFilter<\/span><\/h3>\n
HasQueryFilter<\/code> method we\u2019ve made sure that \u201cdeleted\u201d entities won\u2019t be included in the query result. Let\u2019s see if it works:<\/p>\nvar studentsWithoudDeleted = _context.Students.ToList();<\/pre>\n
HasQueryFilter<\/code> method implemented, the result is different:<\/p>\n![\"HasQueryFilterImplemented\"](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/43-HasQueryFilterImplemented.png\")
<\/a><\/p>\nIgnoreQueryFilter<\/code> to the query:<\/p>\nvar studentsWithDeleted = _context.Students\r\n .IgnoreQueryFilters()\r\n .ToList();\r\n<\/pre>\n
![\"IgnoreQueryFIlter](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/44-IgnoreQueryFIlter-Implemented.png\")
<\/a><\/p>\nDelete a Single Entity with EF Core<\/span><\/h3>\n
Remove<\/code> method or RemoveRange<\/code> method for multiple entities:<\/p>\n[HttpDelete(\"{id}\")]\r\npublic IActionResult Delete(Guid id)\r\n{\r\n var student = _context.Students\r\n .FirstOrDefault(s => s.Id.Equals(id));\r\n\r\n if (student == null)\r\n return BadRequest();\r\n\r\n _context.Remove(student);\r\n _context.SaveChanges();\r\n\r\n return NoContent();\r\n}\r\n<\/pre>\n\n
![\"Delete](\"https:\/\/code-maze.com\/wp-content\/uploads\/2019\/08\/45-Delete-Single-Entity.png\")
<\/a><\/p>\n