Rekursive Entity im Entity Framework loslösen

Question

Ich habe eine Methode zum rekursiven Lösen meiner Objekte im Entity Framework geschrieben. Eigentlich funktioniert es, aber das Problem ist, nach dem Ausführen dieser Methode, die eins zu viele Eigenschaften (die Sammlungen des Objekts) entfernt werden. Im Folgenden mein Code:

public void DetachRec(object objectToDetach) 
{ 
    DetachRec(objectToDetach, new HashSet<object>()); 
} 

// context is my ObjectContext 
private void DetachRec(object objectToDetach, HashSet<object> visitedObjects) 
{ 
    visitedObjects.Add(objectToDetach); 

    if (objectToDetach == null) 
    { 
    return; 
    } 
    Type type = objectToDetach.GetType(); 
    PropertyInfo[] propertyInfos = type.GetProperties(); 
    foreach (PropertyInfo propertyInfo in propertyInfos) 
    { 
    // on to many 
    if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(ICollection<>)) 
    { 

     if (context.Entry(objectToDetach).Collection(propertyInfo.Name).IsLoaded) 
     { 

     var propValue = (IEnumerable) propertyInfo.GetValue(objectToDetach, null); 

     if (propValue != null) 
     { 
      var subcontext = new List<object>(); 

      foreach (var subObject in propValue) 
      { 
      subcontext.Add(subObject); 
      } 
      foreach (var subObject in subcontext) 
      { 
      if (!visitedObjects.Contains(subObject)) 
      { 
       context.DetachRecursive(subObject, visitedObjects); 
      } 
      } 
     } 
     } 
    } 
    // (many to one) 
    else if (propertyInfo.PropertyType.Assembly == type.Assembly) 
    { 
     //the part to detach many-to-one objects 
    } 
    } 

    context.Detach(objectToDetach); 
} 

Answer 1

Bevor die Sammlung Elemente Abnehmen, können Sie den Wert für die Sammlung speichern und die Sammlung Eigenschaft auf null gesetzt. Auf diese Weise verhindern Sie, dass EF die Auflistungselemente entfernt, wenn die Elemente und/oder die übergeordnete Entität getrennt wird. Am Ende des Prozesses werden Sie diese Werte einfach wiederherstellen.

starten, indem Sie die folgenden using zu der Quellcodedatei:

using System.Data.Entity.Infrastructure; 

Veränderung der öffentlichen Implementierungsmethode wie folgt:

public void DetachRec(object objectToDetach) 
{ 
    var visitedObjects = new HashSet<object>(); 
    var collectionsToRestore = new List<Tuple<DbCollectionEntry, object>>(); 
    DetachRec(objectToDetach, visitedObjects, collectionsToRestore); 
    foreach (var item in collectionsToRestore) 
     item.Item1.CurrentValue = item.Item2; 
} 

der private rekursive Methode Signatur:

private void DetachRec(object objectToDetach, HashSet<object> visitedObjects, List<DbCollectionEntry, object>> collectionsToRestore) 

und die eins zu vielenif Blockkörper zu:

var collectionEntry = context.Entry(objectToDetach).Collection(propertyInfo.Name); 
if (collectionEntry.IsLoaded) 
{ 
    var collection = collectionEntry.CurrentValue; 
    if (collection != null) 
    { 
     collectionsToRestore.Add(Tuple.Create(collectionEntry, collection)); 
     collectionEntry.CurrentValue = null; 
     foreach (var item in (IEnumerable)collection) 
     { 
      if (!visitedObjects.Contains(item)) 
      { 
       DetachRec(item, visitedObjects, collectionsToRestore); 
      } 
     } 
    } 
} 

und Sie sind fertig.