Opérateur de conversion C# pour une classe avec une collection récursive

Question

J'ai eu du mal à faire fonctionner une distribution pour une classe qui a une collection de lui-même. Dans le test avec un objet racine qui a deux éléments TypeA dans la liste, lorsque la liste fait le cast implicite ... il entre le code de conversion pour l'élément TypeA de la collection, et parce que c'est le haut de l'arbre, renvoie TypeAIntermediate sans entrer dans la boucle de foreach (ce parfait - il n'y a rien dans SomeAs). Mais quand il retourne l'instance convertie, il semble recommencer en haut du code de conversion pour la racine comme si rien ne s'était passé. Autant que je sache, cela ne s'arrête jamais. J'ai réécrit cette version simplifiée qui suit le même format ... j'espère que je n'ai pas gâché.

//These are models used in a .Net 4.5 EF6 Library 
public class TypeA 
{ 
    public string TypeAStuff; 
    public TypeB JustOneB; 
    public List<TypeA> SomeAs; 


    public static implicit operator TypeAIntermediate(TypeA a) 
    { 
     //New up an Intermediate A to return. 
     TypeAIntermediate aI = new TypeAIntermediate(); 
     //And get ready to do handle the collection... a few ways to do this. 
     List<TypeAIntermediate> children = new List<TypeAIntermediate>(); 

     //...but this appears to create an infinite loop? 
     foreach (TypeA item in a.SomeAs) 
      children.Add(item); //Cast from TypeA to to TypeAIntermediate happens here but will just keeps cycling 

     aI.TypeAStuff = a.TypeAStuff; 
     aI.JustOneB = a.JustOneB; 
     aI.SomeAs = children; 
     return aI; 
    } 
} 

public class TypeB 
{ 
    public string TypeBStuff; 

    public static implicit operator TypeBIntermediate(TypeB b) 
    { 
     TypeBIntermediate bI = new TypeBIntermediate(); 
     bI.TypeBStuff = b.TypeBStuff; 
     return bI; 
    } 
} 

//These Intermediate Classes live in a .Net35 Library - Unity cannot use Libraries compiled for later .Net Versions. 
public class TypeAIntermediate 
{ 
    public string TypeAStuff; 
    public TypeBIntermediate JustOneB; 
    public List<TypeAIntermediate> SomeAs; 
} 

public class TypeBIntermediate 
{ 
    public string TypeBStuff; 
} 

Answer 1

Voici comment vous pouvez écrire cela pour éviter le débordement de pile si vous avez des boucles dans votre hiérarchie.

public static implicit operator TypeAIntermediate(TypeA a) 
{ 
    return Convert(a, new Dictionary<TypeA, TypeAIntermediate>()); 
} 

private static TypeAIntermediate Convert(
    Type A a, 
    Dictionary<TypeA, TypeAIntermediate> lookup) 
{ 
    TypeAIntermediate aI; 
    if(lookup.TryGetValue(a, out aI)) 
    { 
     return aI; 
    } 

    aI = new TypeAintermediate(); 
    lookup.Add(a, aI); 

    List<TypeAIntermediate> children = new List<TypeAIntermediate>(); 
    foreach (TypeA item in a.SomeAs) 
     children.Add(Convert(item, lookup)); 

    aI.TypeAStuff = a.TypeAStuff; 
    aI.JustOneB = a.JustOneB; 
    aI.SomeAs = children; 
    return aI; 
} 

En fait à l'aide d'un dictionnaire, vous pouvez déterminer si un objet TypeA a déjà un objet TypeAIntermediate créé pour elle dans ce cas, vous n'avez pas besoin de le créer à nouveau et juste renvoyer la référence TypeAIntermediate correspondante. Si ce n'est pas le cas, vous devez créer un nouveau TypeAIntermediate et remplir sa collection en appelant de manière récursive la méthode Create qui prend également le dictionnaire.

De plus, si vous avez deux fois la même référence d'objet dans différentes branches, cela créera une seule référence TypeAIntermediate au lieu de deux.