Comment convertir des objets avec des objets imbriqués

Question

J'ai une entité qui est en fait la structure de l'objet arbre (définir uniquement les propriétés pertinentes dans mon entité):

public class TreeItem 
{ 

    public int Id { get; set; } 

    public TreeItem Parent { get; set; } 

    public List<TreeItem> Children { get; set; } 

    ... 

} 

Parent et les propriétés enfants sont correctement définies comme propriétés de navigation. Donc, quand je l'appelle quelque chose comme:

var items = (from ti in context.TreeItem() 
      select ti).ToList<TreeItem>(); 

Je reçois effectivement mes articles dans une structure arborescente, car EF sa magie derrière le rideau et mes parents et remplit les enfants sur ces articles.

Ce que je voudrais faire maintenant est de convertir ces objets en mes objets ViewModel qui sont beaucoup POCO. Pas de fonctionnalité, juste des données.

Je pourrais les convertir en ayant une méthode récursive qui créerait et peuplerait de nouveaux objets, mais y a-t-il un moyen plus simple (en termes de lignes de code de LoC) de faire ce genre de conversion?

Answer 1

En this question connexe plusieurs approches sont discutées:

• L'récursive, sera probablement le plus facile à mettre en œuvre, mais en termes de mise à l'échelle de la profondeur et le nombre d'articles, elle est limitée car elle tend à de façon exponentielle prendre plus de temps et les risques débordant votre pile
• une autre approche serait d'utiliser une pile qui, en termes de mise à l'échelle est beaucoup plus croissance linéaire

Assurez-vous de vérifier la com de Eric Lippert ment au bas de la page. Mise à jour

, pour vous donner une idée de ce que je veux dire:

public static class Extensions 
{ 
    public static IList<R> TransformTree<T, R>(this IEnumerable<T> collection, 
     Func<T, IEnumerable<T>> entitySelector, 
     Func<R, IList<R>> pocoSelector, 
     Func<T, R> transformer) 
    { 
     var transformedList = new List<R>(); 
     var stack = new Stack<IEnumerable<T>>(); 
     var parents = new Dictionary<IEnumerable<T>, R>(); 

     stack.Push(collection); 

     while (stack.Count > 0) 
     { 
      IEnumerable<T> items = stack.Pop(); 

      R transformedParent; 

      IList<R> parentChildren = parents.TryGetValue(items, out transformedParent) 
              ? pocoSelector(transformedParent) 
              : transformedList; 

      foreach (var item in items) 
      { 
       R transformedItem = transformer(item); 
       parentChildren.Add(transformedItem); 

       IEnumerable<T> children = entitySelector(item); 

       stack.Push(children); 
       parents.Add(children, transformedItem); 
      } 
     } 

     return transformedList; 
    } 
} 

appel comme si:

treeItems.TransformTree<TreeItem, TreeItemPoco>(
    (item) => { return item.Children; }, 
    (pocoItem) => { return pocoItem.Children; }, 
    (item) => { return new TreeItemPoco(item); });