具有递归集合的类的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 方法。

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