c＃转换运算符为递归集合类

Question

我一直在努力获得一个演员工作的类具有自己的集合。在使用List中具有两个TypeA元素的根对象进行测试时，当List执行隐式转换时...它将输入集合的TypeA元素的转换代码，并且因为这是树的顶部，所以返回TypeAIntermediate无需进入foreach循环（即完美 - SomeAs中没有任何内容）。但是当它返回转换的实例时，它似乎重新开始在根的转换代码的顶部，就像什么都没有发生。

据我所知，这永远不会停止。我重写了这个遵循相同格式的简化版本......希望我没有搞砸。

//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

下面是如何编写该方法以避免堆栈溢出，如果您的层次结构中存在环路。

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

基本上通过使用字典，你可以确定是否有任何TypeA对象已经为它创造一个TypeAIntermediate对象在这种情况下，你不需要再次创建它，只是返回相应TypeAIntermediate参考。如果它没有，那么你创建一个新的TypeAIntermediate并填充它的集合递归调用Create方法，也需要字典。

此外，如果您在不同分支中有两次相同的对象引用，则只会创建一个参考而不是两个参考。