具有递归集合的类的c＃转换运算符

Question

I've been struggling to get a cast to work for a class that has a collection of itself. In testing with a root object that has two TypeA elements in the List, when the List does the implicit cast... it enters the conversion code for the TypeA element of the collection, and because this is the top of the tree, returns TypeAIntermediate without entering the foreach loop (that perfect - there's nothing in SomeAs). But when it returns the converted instance, it appears to start over at the top of the conversion code for the root like nothing happened.

As far as I can tell this never stops. I rewrote this simplified version that follows the same format... hopefully I didn't mess up.

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

Here's how you can write that to avoid stack overflow if you have loops in your hierarchy.

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

Basically by using a dictionary you can determine if any TypeA object already has a TypeAIntermediate object created for it in which case you don't need to create it again and just return the corresponding TypeAIntermediate reference. If it hasn't then you create a new TypeAIntermediate and populate it's collection be recursively calling the Create method that also takes the dictionary.

Additionally if you have the same object reference twice in different branches this will only create one TypeAIntermediate reference instead of two.