How to update record using Entity Framework Core?

Question

What is the best approach to update database table data in Entity Framework Core?

1. Retrieve the table row, do the changes and save
2. Use keyword Update in DB context and handle exception for item not exist

What are the improved features we can use over EF6?

Answer 1

To update an entity with Entity Framework Core, this is the logical process:

1. Create instance for DbContext class
2. Retrieve entity by key
3. Make changes on entity's properties
4. Save changes

Update() method in DbContext:

Begins tracking the given entity in the Modified state such that it will be updated in the database when SaveChanges() is called.

Update method doesn't save changes in database; instead, it sets states for entries in DbContext instance.

So, We can invoke Update() method before to save changes in database.

I'll assume some object definitions to answer your question:

1. Database name is Store

2. Table name is Product

Product class definition:

public class Product
{
    public int? ProductID { get; set; }
    
    public string ProductName { get; set; }
    
    public string Description { get; set; }
    
    public decimal? UnitPrice { get; set; }
}

DbContext class definition:

public class StoreDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("Your Connection String");

        base.OnConfiguring(optionsBuilder);
    }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Order>(entity =>
        {
            // Set key for entity
            entity.HasKey(p => p.ProductID);
        });
        
        base.OnModelCreating(modelBuilder);
    }
}

Logic to update entity:

using (var context = new StoreDbContext())
{
        // Retrieve entity by id
        // Answer for question #1
        var entity = context.Products.FirstOrDefault(item => item.ProductID == id);
        
        // Validate entity is not null
        if (entity != null)
        {
            // Answer for question #2

            // Make changes on entity
            entity.UnitPrice = 49.99m;
            entity.Description = "Collector's edition";
            
            /* If the entry is being tracked, then invoking update API is not needed. 
              The API only needs to be invoked if the entry was not tracked. 
              https://www.learnentityframeworkcore.com/dbcontext/modifying-data */
            // context.Products.Update(entity);
            
            // Save changes in database
            context.SaveChanges();
        }
}

Answer 2

According to Microsoft docs:

the read-first approach requires an extra database read, and can result in more complex code for handling concurrency conflict

However, you should know that using Update method on DbContext will mark all the fields as modified and will include all of them in the query. If you want to update a subset of fields you should use the Attach method and then mark the desired field as modified manually.

context.Attach(person);
context.Entry(person).Property(p => p.Name).IsModified = true;
context.SaveChanges();

Answer 3

public async Task<bool> Update(MyObject item)
{
    Context.Entry(await Context.MyDbSet.FirstOrDefaultAsync(x => x.Id == item.Id)).CurrentValues.SetValues(item);
    return (await Context.SaveChangesAsync()) > 0;
}

Answer 4

It's super simple

using (var dbContext = new DbContextBuilder().BuildDbContext())
{
    dbContext.Update(entity);
    await dbContext.SaveChangesAsync();
}

Answer 5

Assume we have an entity Student and AppDbContext as follows.

class Student
{
    public int Id { get; set; }
    public string Name { get; set; } = default!;
    public int Age { get; set; }
}


public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> opts) : base(opts) { }

    public DbSet<Student> Students { get; set; }
}

Version A

• CurrentValues can only work for a tracked entity (found).
• Only the changed properties are marked as Modified.
• Automatic property mapping that is useful when using type parameter TEntity instead of a fixed type Student.

async Task Edit_A(int id, Student incoming, AppDbContext db)
{
    if (await db.Students.FindAsync(id) is Student found)
    {
        db.Entry(found).CurrentValues.SetValues(incoming);

        await db.SaveChangesAsync();
    }
}

Version B

• It works only on a tracked entity (found).
• It is not necessary to map all properties because only the changed properties are marked as Modified.
• Manual property mapping so we cannot not use generic type parameter.

async Task Edit_B(int id, Student incoming, AppDbContext db)
{
    if (await db.Students.FindAsync(id) is Student found)
    {
        found.Name = incoming.Name;
        found.Age = incoming.Age; 
        

        await db.SaveChangesAsync();
    }
}

Version C

• Update() works only on an untracked entity (incoming) and makes it tracked. Untracking found before invoking Update(incoming) is mandatory because only one entity can be tracked with the given primary key.
• All properties (including unchanged ones) are marked as Modified. It is less efficient.
• Automatic property mapping that is useful for generic type parameter.

async Task Edit_C(int id, Student incoming, AppDbContext db)
{
    if (await db.Students.FindAsync(id) is Student found)
    {
        db.Students.Entry(found).State = EntityState.Detached;
        db.Students.Update(incoming);
        await db.SaveChangesAsync();
    }
}

Version D

• It is the same as version C. I rewrite again below for the sake of completeness.
• It works only on an untracked entity (incoming) and makes it tracked. Untracking found is mandatory because only one entity can be tracked with the given primary key.
• All properties (including unchanged ones) are marked as Modified. It is less efficient.
• Automatic property mapping that is useful for generic type parameter.

async Task Edit_D(int id, Student incoming, AppDbContext db)
{
    if (await db.Students.FindAsync(id) is Student found)
    {
        db.Students.Entry(found).State = EntityState.Detached;
        db.Students.Entry(incoming).State = EntityState.Modified;
        await db.SaveChangesAsync();
    }
}

Version E

• It works only on an untracked entity (incoming) and makes it tracked. Untracking found is mandatory because only one entity can be tracked with the given primary key.
• It is not necessary to map all properties because only properties (including unchanged ones) marked with IsModified=true will be updated. It is less efficient if you mark IsModified=true for unchanged properties.
• Manual property mapping so we cannot not use generic type parameter.

async Task Edit_E(int id, Student incoming, AppDbContext db)
{
    if (await db.Students.FindAsync(id) is Student found)
    {
        db.Students.Entry(found).State = EntityState.Detached;
        db.Students.Entry(incoming).Property(s => s.Name).IsModified = true;
        db.Students.Entry(incoming).Property(s => s.Age).IsModified = true;
        await db.SaveChangesAsync();
    }
}

I set it as a Community Wiki, feel free to edit as many as you want.

Answer 6

Microsoft Docs gives us two approaches.

Recommended HttpPost Edit code: Read and update

This is the same old way we used to do in previous versions of Entity Framework. and this is what Microsoft recommends for us.

Advantages

• Prevents overposting
• EFs automatic change tracking sets the Modified flag on the fields that are changed by form input.

Alternative HttpPost Edit code: Create and attach

an alternative is to attach an entity created by the model binder to the EF context and mark it as modified.

As mentioned in the other answer the read-first approach requires an extra database read, and can result in more complex code for handling concurrency conflicts.

Answer 7

After going through all the answers I thought i will add two simple options

1. If you already accessed the record using FirstOrDefault() with tracking enabled (without using .AsNoTracking() function as it will disable tracking) and updated some fields then you can simply call context.SaveChanges()

2. In other case either you have entity posted to server using HtppPost or you disabled tracking for some reason then you should call context.Update(entityName) before context.SaveChanges()

1st option will only update the fields you changed but 2nd option will update all the fields in the database even though none of the field values were actually updated :)

Answer 8

A more generic approach

To simplify this approach an "id" interface is used

public interface IGuidKey
{
    Guid Id { get; set; }
}

The helper method

public static void Modify<T>(this DbSet<T> set, Guid id, Action<T> func)
    where T : class, IGuidKey, new()
{
    var target = new T
    {
        Id = id
    };
    var entry = set.Attach(target);
    func(target);
    foreach (var property in entry.Properties)
    {
        var original = property.OriginalValue;
        var current = property.CurrentValue;

        if (ReferenceEquals(original, current))
        {
            continue;
        }

        if (original == null)
        {
            property.IsModified = true;
            continue;
        }

        var propertyIsModified = !original.Equals(current);
        property.IsModified = propertyIsModified;
    }
}

Usage

dbContext.Operations.Modify(id, x => { x.Title = "aaa"; });

Answer 9

Personally I see the operation that you are doing is an upsert operation, where if data already exist we update, else we insert. There is one good library from Flexlab to support Upsert operation with this syntax

var country = new Country
{
    Name = "Australia",
    ISO = "AU",
    Created = DateTime.UtcNow,
};


await DataContext.Upsert(country)
    .On(c => c.ISO)
    .UpdateColumns(c => new Country
    {
        Name = "Australia"
        Updated = DateTime.UtcNow,
    })
    .RunAsync();

The code will check for the property Country.ISO in the table. If it does not exist yet it will insert new row altogether into the table. Else if any row with the same Country.ISO already exist it will update columns Country.Name and Country.Updated for that row.

This method is very fast because we only do one call to the database instead of two calls to check if the data already exist before we updating or inserting the data.

Note that this answer does not apply to you if your intend is not to do the Upsert operation

Answer 10

Even though this is an old question and the answer(s) are technically correct, I would like to point out that certain decisions on how we architect our software solution do affect the way we approach and use ORM(s) such as EF.

As a result, they affect what we accept as the best answer, too.

In other words, why Christian's answer is not the accepted one?

In a layered architecture that follows basic DDD, the Product class would probably be a domain model with methods to implement (any) business logic. In this case, the UnitPrice property would be set or updated by such a method, say, CalculatePrice instead of directly assigning a value to it:

public class Product
{
    public int ProductID { get; private set; }

    public decimal? UnitPrice { get; private set; }
    ...
    public Product CalculatePrice(...)
    {
        UnitPrice = ...;
    }
}

Having such a domain model, do you really need to ask which of its properties to update in the data store? Probably not. All you need is a reference to the tracked object to update. In the application layer the code becomes:

var product = repository.Find(productId);

if (product != null)
{
    product.CalculatePrice(...);

    repository.Update(product);
}

The implementation of the repository's Update method is:

public Product Update(Product entity)
{
    dbContext.Update(entity);

    dbContext.SaveChanges();

    return entity;
}

With regard to the OP, the above example showcases how design decisions affect both the meaning of our questions ("[...]best approach to update database") and which answer we mark as the accepted one.