Як додати / оновити дочірні сутності під час оновлення материнської сутності в EF

Дві сутності мають відношення один до багатьох (побудований за кодом першими вільними 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; }
}

У своєму контролері WebApi у мене є дії зі створення батьківського об'єкта (який працює чудово) та оновлення материнської сутності (яка має певні проблеми). Дія оновлення виглядає так:

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

Наразі у мене є дві ідеї:

1. Отримати гусеничний батьківський об'єкт з ім'ям existingпо model.Idі присвоєння значення в modelодин за іншим до об'єкта. Це звучить нерозумно. І model.Childrenя не знаю, яка дитина нова, яка дитина модифікована (або навіть видалена).

2. Створіть нову материнську сутність за допомогою modelі додайте її до DbContext і збережіть її. Але як DbContext може знати стан дітей (нове додавання / видалення / модифікація)?

Який правильний спосіб реалізації цієї функції?

Оскільки модель, яка розміщується на контролері WebApi, відірвана від будь-якого контексту сукупності (EF), єдиним варіантом є завантаження об’єктного графіка (батька, включаючи його дітей) з бази даних та порівняння, яких дітей додано, видалено або оновлено. (Якщо ви не відстежуєте зміни за допомогою власного механізму відстеження під час відключеного стану (у браузері чи деінде), який, на мою думку, є складнішим за наступне.) Це може виглядати приблизно так:

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.SetValuesможе приймати будь-який об’єкт і відображає значення властивостей доданому об'єкту на основі імені властивості. Якщо імена властивостей у вашій моделі відрізняються від імен у сутності, ви не можете використовувати цей метод і повинні призначити значення по одному.

Я возився з чимось подібним ...

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

яку ви можете зателефонувати з чимось на кшталт:

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

На жаль, ця справа перепадає, якщо для дочірнього типу є властивості колекції, які також потрібно оновити. Розглянемо спробу вирішити це шляхом передачі IRepository (з основними методами CRUD), який відповідав би за виклик UpdateChildCollection самостійно. Буде закликати репо замість прямих дзвінків на DbContext.Entry.

Поняття не маю, як це все буде працювати в масштабах, але не впевнений, що ще робити з цією проблемою.

Добре, хлопці. Я відповів цю відповідь один раз, але втратив її по дорозі. абсолютне катування, коли ви знаєте, що є кращий спосіб, але не можете його згадати чи знайти! Це дуже просто. Я просто перевірив це декількома способами.

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

Ви можете замінити весь список на новий! Код SQL видалить і додасть об'єкти за потребою. Не потрібно себе цим хвилювати. Обов’язково включіть дитячу колекцію або без кісток. Удачі!

Якщо ви використовуєте EntityFrameworkCore, ви можете зробити наступне в дії після контролера ( метод Attach рекурсивно додає властивості навігації, включаючи колекції):

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

Передбачається, що кожне оновлене об'єднання має всі властивості, встановлені та надані у даних про пост від клієнта (наприклад, не буде працювати для часткового оновлення сутності).

Вам також потрібно переконатися, що ви використовуєте для цієї операції новий / виділений контекст бази даних сутності.

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

Ось як я вирішив цю проблему. Таким чином, EF знає, що додати, що оновити.

Існує кілька проектів, які полегшують взаємодію між клієнтом і сервером, наскільки це стосується збереження цілого графіка об'єкта.

Ось два, які ви хочете подивитися:

• Простежувані об'єкти
• Вітерець №

Обидва вищезазначені проекти розпізнають відключені об'єкти, коли вони повертаються на сервер, виявляють та зберігають зміни та повертаються до даних, пов’язаних із клієнтом.

Просто доказ концепції Controler.UpdateModel не працюватиме правильно.

Повний клас тут :

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 дійсно дав мені відповідь за мою ситуацію в тому, що передане в моделі відсторонено. Для мене те, що в кінцевому підсумку спрацювало, - це збереження переданих у моделі спочатку ... потім продовження додавання дітей, як я вже був раніше:

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

Для розробників VB.NET Використовуйте цей загальний підрозділ для позначення стану дитини, простий у використанні

Примітки:

• PromatCon: об'єкт сутності
• amList: це дочірній список, який ви хочете додати чи змінити
• rList: це дочірній список, який потрібно видалити

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

джерело

Ось мій код, який працює чудово.

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