Comment ajouter / mettre à jour des entités enfants lors de la mise à jour d'une entité parente dans EF

Les deux entités sont une relation un-à-plusieurs (construite par le code first fluent api).

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

Dans mon contrôleur WebApi, j'ai des actions pour créer une entité parente (qui fonctionne bien) et mettre à jour une entité parente (qui a un problème). L'action de mise à jour ressemble à ceci:

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

Actuellement, j'ai deux idées:

1. Obtenez une entité parent suivie nommée existingpar model.Idet attribuez des valeurs modelune par une à l'entité. Cela semble stupide. Et dans model.Childrenje ne sais pas quel enfant est nouveau, quel enfant est modifié (ou même supprimé).

2. Créez une nouvelle entité parente via model, attachez-la au DbContext et enregistrez-la. Mais comment le DbContext peut-il connaître l'état des enfants (nouvel ajout / suppression / modification)?

Quelle est la bonne façon d'implémenter cette fonctionnalité?

Étant donné que le modèle qui est publié sur le contrôleur WebApi est détaché de tout contexte de structure d'entité (EF), la seule option est de charger le graphique d'objet (parent, y compris ses enfants) à partir de la base de données et de comparer les enfants qui ont été ajoutés, supprimés ou actualisé. (À moins que vous ne suiviez les modifications avec votre propre mécanisme de suivi pendant l'état détaché (dans le navigateur ou ailleurs), ce qui à mon avis est plus complexe que ce qui suit.) Cela pourrait ressembler à ceci:

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.SetValuespeut prendre n'importe quel objet et mappe les valeurs de propriété à l'entité attachée en fonction du nom de la propriété. Si les noms de propriété de votre modèle sont différents des noms de l'entité, vous ne pouvez pas utiliser cette méthode et devez attribuer les valeurs une par une.

J'ai joué avec quelque chose comme ça ...

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 vous pouvez appeler avec quelque chose comme:

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

Malheureusement, cela tombe en quelque sorte s'il y a des propriétés de collection sur le type enfant qui doivent également être mises à jour. Envisager d'essayer de résoudre cela en passant un IRepository (avec des méthodes CRUD de base) qui serait responsable d'appeler UpdateChildCollection seul. Appellerait le dépôt au lieu d'appels directs à DbContext.Entry.

Je n'ai aucune idée de la façon dont tout cela fonctionnera à grande échelle, mais je ne sais pas quoi faire d'autre avec ce problème.

Ok les gars. J'ai eu cette réponse une fois mais je l'ai perdue en cours de route. torture absolue quand vous savez qu'il existe un meilleur moyen mais que vous ne pouvez pas vous en souvenir ou le trouver! C'est très simple. Je viens de le tester de plusieurs façons.

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

Vous pouvez remplacer toute la liste par une nouvelle! Le code SQL supprimera et ajoutera des entités selon les besoins. Inutile de vous en préoccuper. Assurez-vous d'inclure la collection enfant ou pas de dés. Bonne chance!

Si vous utilisez EntityFrameworkCore, vous pouvez effectuer les opérations suivantes dans l'action de publication de votre contrôleur (la méthode Attach attache de manière récursive les propriétés de navigation, y compris les collections):

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

On suppose que chaque entité qui a été mise à jour a toutes les propriétés définies et fournies dans les données de publication du client (par exemple, ne fonctionnera pas pour une mise à jour partielle d'une entité).

Vous devez également vous assurer que vous utilisez un nouveau contexte de base de données de structure d'entités dédié pour cette opération.

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

C'est ainsi que j'ai résolu ce problème. De cette façon, EF sait lequel ajouter et lequel mettre à jour.

Il existe quelques projets qui facilitent l'interaction entre le client et le serveur en ce qui concerne la sauvegarde d'un graphe d'objets entier.

En voici deux que vous voudriez examiner:

• Entités traçables
• Brise#

Les deux projets ci-dessus reconnaissent les entités déconnectées lorsqu'elles sont renvoyées au serveur, détectent et enregistrent les modifications et retournent aux données affectées par le client.

Une simple preuve de concept Controler.UpdateModel ne fonctionnera pas correctement.

Classe complète ici :

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 m'a vraiment donné la réponse à ma situation en ce que le modèle passé était détaché. Pour moi, ce qui a finalement fonctionné a été de sauvegarder d'abord le modèle passé ... puis de continuer à ajouter les enfants comme je l'étais déjà auparavant:

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

Pour les développeurs VB.NET Utilisez ce sous générique pour marquer l'état enfant, facile à utiliser

Remarques:

• PromatCon: l'objet entité
• amList: est la liste enfant que vous souhaitez ajouter ou modifier
• rList: est la liste enfant que vous souhaitez supprimer

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

la source

Voici mon code qui fonctionne très bien.

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