Como adicionar / atualizar entidades filhas ao atualizar uma entidade pai no EF

As duas entidades são um-para-muitos relacionamento (construído pelo código primeiro API fluente).

public class Parent
{
    public Parent()
    {
        this.Children = new List<Child>();
    }

    public int Id { get; set; }

    public virtual ICollection<Child> Children { get; set; }
}

public class Child
{
    public int Id { get; set; }

    public int ParentId { get; set; }

    public string Data { get; set; }
}

No meu controlador WebApi, tenho ações para criar uma entidade pai (que está funcionando bem) e atualizar uma entidade pai (que tem algum problema). A ação de atualização é semelhante a:

public void Update(UpdateParentModel model)
{
    //what should be done here?
}

Atualmente, tenho duas idéias:

1. Obtenha uma entidade pai rastreada nomeada existingpor model.Ide atribua valores modelum a um à entidade. Isso parece estúpido. E model.Childrennão sei qual filho é novo, qual filho é modificado (ou mesmo excluído).

2. Crie uma nova entidade pai via modele anexe-a ao DbContext e salve-a. Mas como o DbContext pode conhecer o estado dos filhos (nova adição / exclusão / modificação)?

Qual é a maneira correta de implementar esse recurso?

Como o modelo que é lançado no controlador WebApi é desanexado de qualquer contexto de entidade-estrutura (EF), a única opção é carregar o gráfico de objeto (pai, incluindo seus filhos) do banco de dados e comparar quais filhos foram adicionados, excluídos ou Atualizada. (A menos que você rastreie as alterações com seu próprio mecanismo de rastreamento durante o estado desanexado (no navegador ou em qualquer outro local) que, na minha opinião, seja mais complexo do que o seguinte).

public void Update(UpdateParentModel model)
{
    var existingParent = _dbContext.Parents
        .Where(p => p.Id == model.Id)
        .Include(p => p.Children)
        .SingleOrDefault();

    if (existingParent != null)
    {
        // Update parent
        _dbContext.Entry(existingParent).CurrentValues.SetValues(model);

        // Delete children
        foreach (var existingChild in existingParent.Children.ToList())
        {
            if (!model.Children.Any(c => c.Id == existingChild.Id))
                _dbContext.Children.Remove(existingChild);
        }

        // Update and Insert children
        foreach (var childModel in model.Children)
        {
            var existingChild = existingParent.Children
                .Where(c => c.Id == childModel.Id)
                .SingleOrDefault();

            if (existingChild != null)
                // Update child
                _dbContext.Entry(existingChild).CurrentValues.SetValues(childModel);
            else
            {
                // Insert child
                var newChild = new Child
                {
                    Data = childModel.Data,
                    //...
                };
                existingParent.Children.Add(newChild);
            }
        }

        _dbContext.SaveChanges();
    }
}

...CurrentValues.SetValuespode levar qualquer objeto e mapear valores de propriedade para a entidade anexada com base no nome da propriedade. Se os nomes de propriedades em seu modelo forem diferentes dos nomes na entidade, você não poderá usar este método e deverá atribuir os valores um a um.

Eu tenho mexido com algo assim ...

protected void UpdateChildCollection<Tparent, Tid , Tchild>(Tparent dbItem, Tparent newItem, Func<Tparent, IEnumerable<Tchild>> selector, Func<Tchild, Tid> idSelector) where Tchild : class
    {
        var dbItems = selector(dbItem).ToList();
        var newItems = selector(newItem).ToList();

        if (dbItems == null && newItems == null)
            return;

        var original = dbItems?.ToDictionary(idSelector) ?? new Dictionary<Tid, Tchild>();
        var updated = newItems?.ToDictionary(idSelector) ?? new Dictionary<Tid, Tchild>();

        var toRemove = original.Where(i => !updated.ContainsKey(i.Key)).ToArray();
        var removed = toRemove.Select(i => DbContext.Entry(i.Value).State = EntityState.Deleted).ToArray();

        var toUpdate = original.Where(i => updated.ContainsKey(i.Key)).ToList();
        toUpdate.ForEach(i => DbContext.Entry(i.Value).CurrentValues.SetValues(updated[i.Key]));

        var toAdd = updated.Where(i => !original.ContainsKey(i.Key)).ToList();
        toAdd.ForEach(i => DbContext.Set<Tchild>().Add(i.Value));
    }

que você pode chamar com algo como:

UpdateChildCollection(dbCopy, detached, p => p.MyCollectionProp, collectionItem => collectionItem.Id)

Infelizmente, isso meio que cai se houver propriedades de coleção no tipo filho que também precisam ser atualizadas. Considere tentar resolver isso passando um IRepository (com métodos básicos de CRUD) que seria responsável por chamar UpdateChildCollection por conta própria. Chamaria o repo em vez de chamadas diretas para DbContext.Entry.

Não tenho idéia de como tudo isso funcionará em escala, mas não tenho certeza do que mais fazer com esse problema.

Ok pessoal. Eu tive essa resposta uma vez, mas a perdi no caminho. tortura absoluta quando você sabe que há uma maneira melhor, mas não consegue se lembrar ou encontrar! É muito simples. Eu apenas testei de várias maneiras.

var parent = _dbContext.Parents
  .Where(p => p.Id == model.Id)
  .Include(p => p.Children)
  .FirstOrDefault();

parent.Children = _dbContext.Children.Where(c => <Query for New List Here>);
_dbContext.Entry(parent).State = EntityState.Modified;

_dbContext.SaveChanges();

Você pode substituir a lista inteira por uma nova! O código SQL removerá e adicionará entidades conforme necessário. Não há necessidade de se preocupar com isso. Certifique-se de incluir a coleção infantil ou nenhum dado. Boa sorte!

Se você estiver usando EntityFrameworkCore, poderá fazer o seguinte na ação pós-controlador (o método Attach anexa recursivamente as propriedades de navegação, incluindo coleções):

_context.Attach(modelPostedToController);

IEnumerable<EntityEntry> unchangedEntities = _context.ChangeTracker.Entries().Where(x => x.State == EntityState.Unchanged);

foreach(EntityEntry ee in unchangedEntities){
     ee.State = EntityState.Modified;
}

await _context.SaveChangesAsync();

Supõe-se que cada entidade que foi atualizada possui todas as propriedades definidas e fornecidas nos dados de postagem do cliente (por exemplo, não funcionará para atualização parcial de uma entidade).

Você também precisa certificar-se de estar usando um contexto de banco de dados de estrutura de entidade novo / dedicado para esta operação.

public async Task<IHttpActionResult> PutParent(int id, Parent parent)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != parent.Id)
            {
                return BadRequest();
            }

            db.Entry(parent).State = EntityState.Modified;

            foreach (Child child in parent.Children)
            {
                db.Entry(child).State = child.Id == 0 ? EntityState.Added : EntityState.Modified;
            }

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ParentExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return Ok(db.Parents.Find(id));
        }

Foi assim que resolvi esse problema. Dessa forma, a EF sabe qual adicionar e quais atualizar.

Existem alguns projetos por aí que facilitam a interação entre o cliente e o servidor no que diz respeito a salvar um gráfico inteiro de objetos.

Aqui estão dois que você gostaria de ver:

• Entidades Rastreáveis
• Brisa#

Os dois projetos acima reconhecem as entidades desconectadas quando retornadas ao servidor, detectam e salvam as alterações e retornam aos dados afetados pelo cliente.

Apenas a prova de conceito Controler.UpdateModel não funcionará corretamente.

Classe completa aqui :

const string PK = "Id";
protected Models.Entities con;
protected System.Data.Entity.DbSet<T> model;

private void TestUpdate(object item)
{
    var props = item.GetType().GetProperties();
    foreach (var prop in props)
    {
        object value = prop.GetValue(item);
        if (prop.PropertyType.IsInterface && value != null)
        {
            foreach (var iItem in (System.Collections.IEnumerable)value)
            {
                TestUpdate(iItem);
            }
        }
    }

    int id = (int)item.GetType().GetProperty(PK).GetValue(item);
    if (id == 0)
    {
        con.Entry(item).State = System.Data.Entity.EntityState.Added;
    }
    else
    {
        con.Entry(item).State = System.Data.Entity.EntityState.Modified;
    }

}

@ Charles McIntosh realmente me deu a resposta para minha situação, pois o modelo passado foi desanexado. Para mim, o que funcionou foi salvar primeiro o modelo passado ... depois continuar adicionando os filhos como eu já era antes:

public async Task<IHttpActionResult> GetUPSFreight(PartsExpressOrder order)
{
    db.Entry(order).State = EntityState.Modified;
    db.SaveChanges();
  ...
}

Para desenvolvedores do VB.NET Use essa sub genérica para marcar o estado filho, fácil de usar

Notas:

• PromatCon: o objeto da entidade
• amList: é a lista filho que você deseja adicionar ou modificar
• rList: é a lista filho que você deseja remover

updatechild(objCas.ECC_Decision, PromatCon.ECC_Decision.Where(Function(c) c.rid = objCas.rid And Not objCas.ECC_Decision.Select(Function(x) x.dcid).Contains(c.dcid)).toList)

Sub updatechild(Of Ety)(amList As ICollection(Of Ety), rList As ICollection(Of Ety))
        If amList IsNot Nothing Then
            For Each obj In amList
                Dim x = PromatCon.Entry(obj).GetDatabaseValues()
                If x Is Nothing Then
                    PromatCon.Entry(obj).State = EntityState.Added
                Else
                    PromatCon.Entry(obj).State = EntityState.Modified
                End If
            Next
        End If

        If rList IsNot Nothing Then
            For Each obj In rList.ToList
                PromatCon.Entry(obj).State = EntityState.Deleted
            Next
        End If
End Sub

PromatCon.SaveChanges()

var parent = context.Parent.FirstOrDefault(x => x.Id == modelParent.Id);
if (parent != null)
{
  parent.Childs = modelParent.Childs;
}

fonte

Aqui está o meu código que funciona muito bem.

public async Task<bool> UpdateDeviceShutdownAsync(Guid id, DateTime shutdownAtTime, int areaID, decimal mileage,
        decimal motohours, int driverID, List<int> commission,
        string shutdownPlaceDescr, int deviceShutdownTypeID, string deviceShutdownDesc,
        bool isTransportation, string violationConditions, DateTime shutdownStartTime,
        DateTime shutdownEndTime, string notes, List<Guid> faultIDs )
        {
            try
            {
                using (var db = new GJobEntities())
                {
                    var isExisting = await db.DeviceShutdowns.FirstOrDefaultAsync(x => x.ID == id);

                    if (isExisting != null)
                    {
                        isExisting.AreaID = areaID;
                        isExisting.DriverID = driverID;
                        isExisting.IsTransportation = isTransportation;
                        isExisting.Mileage = mileage;
                        isExisting.Motohours = motohours;
                        isExisting.Notes = notes;                    
                        isExisting.DeviceShutdownDesc = deviceShutdownDesc;
                        isExisting.DeviceShutdownTypeID = deviceShutdownTypeID;
                        isExisting.ShutdownAtTime = shutdownAtTime;
                        isExisting.ShutdownEndTime = shutdownEndTime;
                        isExisting.ShutdownStartTime = shutdownStartTime;
                        isExisting.ShutdownPlaceDescr = shutdownPlaceDescr;
                        isExisting.ViolationConditions = violationConditions;

                        // Delete children
                        foreach (var existingChild in isExisting.DeviceShutdownFaults.ToList())
                        {
                            db.DeviceShutdownFaults.Remove(existingChild);
                        }

                        if (faultIDs != null && faultIDs.Any())
                        {
                            foreach (var faultItem in faultIDs)
                            {
                                var newChild = new DeviceShutdownFault
                                {
                                    ID = Guid.NewGuid(),
                                    DDFaultID = faultItem,
                                    DeviceShutdownID = isExisting.ID,
                                };

                                isExisting.DeviceShutdownFaults.Add(newChild);
                            }
                        }

                        // Delete all children
                        foreach (var existingChild in isExisting.DeviceShutdownComissions.ToList())
                        {
                            db.DeviceShutdownComissions.Remove(existingChild);
                        }

                        // Add all new children
                        if (commission != null && commission.Any())
                        {
                            foreach (var cItem in commission)
                            {
                                var newChild = new DeviceShutdownComission
                                {
                                    ID = Guid.NewGuid(),
                                    PersonalID = cItem,
                                    DeviceShutdownID = isExisting.ID,
                                };

                                isExisting.DeviceShutdownComissions.Add(newChild);
                            }
                        }

                        await db.SaveChangesAsync();

                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
            }

            return false;
        }