MSDN Documentation

Updating Data with Entity Framework

Entity Framework (EF) provides a streamlined and object-oriented approach to managing data persistence. Updating data in your database involves fetching the relevant entity, making modifications to its properties, and then saving those changes back to the data source. EF handles the translation of these object-level operations into SQL commands.

Fetching and Modifying Entities

The most common way to update data is to first retrieve the entity you want to modify from the database using your DbContext. Once you have the entity instance, you can change its properties directly.

// Assuming 'context' is an instance of your DbContext
var product = context.Products.Find(productId);

if (product != null)
{
    product.Name = "Updated Product Name";
    product.Price = 25.99m;
    context.SaveChanges();
}
                

In this example, context.Products.Find(productId) retrieves a single product based on its primary key. If the product is found, its Name and Price properties are updated. Finally, context.SaveChanges() persists these modifications to the database.

Attaching and Modifying Detached Entities

Sometimes, you might receive an entity from an external source (e.g., a web request) that is not currently tracked by the DbContext. These are called detached entities. To update such entities, you need to attach them to the context and mark them as modified.

// Assuming 'detachedProduct' is an entity received from somewhere else
var detachedProduct = new Product { Id = 1, Name = "New Name", Price = 19.99m };

if (detachedProduct != null)
{
    context.Entry(detachedProduct).State = EntityState.Modified;
    context.SaveChanges();
}
                

Partially Updating Entities

If you only want to update specific properties of an entity, you can explicitly tell EF which properties have changed. This can be more efficient as it generates only the necessary SQL `UPDATE` statements.

var product = context.Products.Find(productId);

if (product != null)
{
    // Only update the Price
    context.Entry(product).Property(p => p.Price).IsModified = true;
    product.Price = 29.99m;
    context.SaveChanges();
}
                

This approach is useful when you need fine-grained control over which fields are updated.

Handling Concurrency Conflicts

Concurrency conflicts can occur when multiple users or processes attempt to update the same data simultaneously. EF provides mechanisms to handle these conflicts.

• Optimistic Concurrency: EF can be configured to detect concurrency conflicts by using timestamp columns or version numbers in your database tables. When a conflict is detected during SaveChanges(), an exception (typically DbUpdateConcurrencyException) is thrown, allowing you to handle it.
• Resolving Conflicts: You can choose to reload the original values from the database, merge the changes, or adopt the incoming values.

try
{
    context.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
    // Handle the concurrency conflict
    // For example, reload the entity and reapply changes, or inform the user
    var entry = ex.Entries.Single();
    var databaseValues = entry.GetDatabaseValues();

    if (databaseValues == null)
    {
        // The entity has been deleted by another user
        Console.WriteLine("The entity you were trying to update has been deleted.");
    }
    else
    {
        // Reload the original values and update the client's object
        var databaseProduct = (Product)databaseValues.ToObject();
        // Decide how to resolve: e.g., refresh from DB, prompt user, etc.
        Console.WriteLine("Concurrency conflict detected. Database has been updated by another user.");
    }
}
                

Updating Related Entities

When updating entities that have relationships, EF can also manage the related data. You can update properties of related entities, or change the relationships themselves.

For example, if you have an Order entity with a collection of OrderItems:

var order = context.Orders.Include(o => o.OrderItems).FirstOrDefault(o => o.Id == orderId);

if (order != null)
{
    // Update an existing item
    var itemToUpdate = order.OrderItems.FirstOrDefault(oi => oi.Id == itemId);
    if (itemToUpdate != null)
    {
        itemToUpdate.Quantity = 5;
    }

    // Add a new item
    order.OrderItems.Add(new OrderItem { ProductId = newProductId, Quantity = 2 });

    context.SaveChanges();
}
                

EF's change tracking mechanism automatically detects additions and modifications to the OrderItems collection and generates the appropriate SQL commands to update the database.