¿Cómo actualizar el registro usando el núcleo del marco de la entidad?

¿Cuál es el mejor enfoque para actualizar los datos de una tabla de base de datos en el núcleo de trabajo del marco de entidad?

1. Recupere la fila de la tabla, haga los cambios y guarde
2. Use la actualización de palabras clave en el contexto de la base de datos y maneje la excepción para el elemento que no existe

¿Cuáles son las características mejoradas que podemos usar en EF6?

Para actualizar una entidad con Entity Framework Core, este es el proceso lógico:

1. Crear instancia para DbContextclase
2. Recuperar entidad por clave
3. Realizar cambios en las propiedades de la entidad
4. Guardar cambios

Update()método en DbContext:

Comienza a rastrear la entidad dada en el estado Modificado de modo que se actualizará en la base de datos cuando SaveChanges()se llame.

El método de actualización no guarda los cambios en la base de datos; en su lugar, establece estados para las entradas en la instancia de DbContext.

Entonces, podemos invocar el Update()método antes para guardar los cambios en la base de datos.

Asumiré algunas definiciones de objetos para responder a su pregunta:

1. El nombre de la base de datos es Store

2. El nombre de la tabla es Producto

Definición de clase de producto:

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

Definición de la clase DbContext:

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);
    }
}

Lógica para actualizar entidad:

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();
        }
}

Según documentos de Microsoft :

El enfoque de lectura primero requiere una lectura de base de datos adicional y puede resultar en un código más complejo para manejar conflictos de concurrencia

Sin embargo, debe saber que el uso del método Update en DbContext marcará todos los campos como modificados y los incluirá todos en la consulta. Si desea actualizar un subconjunto de campos, debe usar el método Adjuntar y luego marcar el campo deseado como modificado manualmente.

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

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;
}

Microsoft Docs nos ofrece dos enfoques.

Código de edición HttpPost recomendado : leer y actualizar

Esta es la misma forma antigua que solíamos hacer en versiones anteriores de Entity Framework. y esto es lo que Microsoft nos recomienda.

Ventajas

• Evita la sobreimpresión
• El seguimiento automático de cambios de EF establece la marca Modifieden los campos que se modifican mediante la entrada del formulario.

Código alternativo de edición de HttpPost: crear y adjuntar

una alternativa es adjuntar una entidad creada por el enlazador de modelos al contexto EF y marcarla como modificada.

Como se mencionó en la otra respuesta, el enfoque de lectura primero requiere una lectura adicional de la base de datos y puede resultar en un código más complejo para manejar conflictos de concurrencia.

Es super simple

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

Después de revisar todas las respuestas, pensé que agregaría dos opciones simples

1. Si ya accedió al registro usando FirstOrDefault () con el seguimiento habilitado (sin usar la función .AsNoTracking (), ya que deshabilitará el seguimiento) y actualizó algunos campos, simplemente puede llamar a context.SaveChanges ()

2. En otro caso, ha publicado la entidad en el servidor utilizando HtppPost o ha desactivado el seguimiento por alguna razón, entonces debe llamar a context.Update (entityName) antes que context.SaveChanges ()

La primera opción solo actualizará los campos que cambió, pero la segunda opción actualizará todos los campos de la base de datos, aunque ninguno de los valores de campo se actualizó realmente :)

Un enfoque más genérico

Para simplificar este enfoque se utiliza una interfaz "id"

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

El método de ayuda

    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;
        }
    }

Uso

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