Saving Data with Entity Framework

Saving data in Entity Framework involves managing the state of entities and then persisting those changes to the database. Entity Framework tracks changes made to entities within a context and provides methods to save these changes efficiently.

The SaveChanges Method

The primary method for persisting changes is SaveChanges() on your DbContext instance. This method inspects all tracked entities, detects the changes made (insertions, updates, deletions), generates the appropriate SQL commands, and executes them against the database.

Adding New Entities

To add a new entity, you create an instance of your entity class and add it to the appropriate DbSet in your context. Then, call SaveChanges().

C#
public void AddNewProduct(string name, decimal price)
{
    using (var context = new MyDbContext())
    {
        var newProduct = new Product
        {
            Name = name,
            Price = price
        };

        context.Products.Add(newProduct);
        context.SaveChanges(); // Inserts the new product into the database
    }
}

Modifying Existing Entities

When you retrieve an entity from the context, it's automatically tracked. You can then modify its properties directly. When SaveChanges() is called, Entity Framework detects these modifications and generates an UPDATE statement.

C#
public void UpdateProductPrice(int productId, decimal newPrice)
{
    using (var context = new MyDbContext())
    {
        var product = context.Products.Find(productId);
        if (product != null)
        {
            product.Price = newPrice;
            context.SaveChanges(); // Updates the product in the database
        }
    }
}

Deleting Entities

To delete an entity, retrieve it from the context and then call the Remove() method on the context's DbSet, followed by SaveChanges().

C#
public void DeleteProduct(int productId)
{
    using (var context = new MyDbContext())
    {
        var product = context.Products.Find(productId);
        if (product != null)
        {
            context.Products.Remove(product);
            context.SaveChanges(); // Deletes the product from the database
        }
    }
}

Handling Multiple Operations

SaveChanges() can persist multiple insertions, updates, and deletions in a single database round trip, making it efficient for batch operations.

C#
public void ProcessOrder(Order order, List items)
{
    using (var context = new MyDbContext())
    {
        context.Orders.Add(order);
        context.OrderItems.AddRange(items); // Efficiently adds multiple items

        // Assume some existing order items might be updated or deleted here too

        context.SaveChanges(); // All operations are committed together
    }
}

Concurrency Control

Entity Framework supports optimistic concurrency. If a record has been modified by another user or process between the time it was loaded and when SaveChanges() is called, a DbUpdateConcurrencyException is thrown. You can catch this exception and implement strategies to handle conflicts, such as retrying the operation, merging changes, or informing the user.

C#
try
{
    context.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
    // Handle concurrency conflict
    // For example, reload the entity and reapply user changes or inform the user
    foreach (var entry in ex.Entries)
    {
        var databaseValues = entry.GetDatabaseValues();
        // ... logic to handle conflict resolution ...
    }
    // Re-throw or handle as needed
    throw;
}

Configuration for Saving Data

You can configure how Entity Framework saves data through various settings in your DbContext, including:

SaveChange(bool acceptAllChangesOnSuccess): Controls whether the context's change tracking is reset after a successful save.
SaveChanges(ICollection<ObjectStateEntry> stateEntries): An advanced overload for manually specifying which entities to save.

By effectively using the SaveChanges() method and understanding Entity Framework's change tracking, you can efficiently persist data and manage your application's state.