Best practice for recursive class

Question

Problem:

I want to build a class for a custom dice. But it should also provide the following:

1. Every side can contain an other dice
2. The number of sides should be dynamically expandable, but must at least contain one
   • Logically the dice need to have a currentSide
3. Every side has a property, which provides the content of this side (on a D6, it would be "4")

So far so good, I went and made two classes dice and side and gave them the properties I think they needed.

public class Side
{
    //public bool HasDice { get { return Dice != null; } } - Removed not needed
    public Dice Dice { get; set; }
    public string Value { get; set; }
}

public class Dice
{
    public ObservableCollection<Side> Sides { get; set; }
    public string Name { get; set; }
    public Side CurrentSide { get; set; }
}

Is this right, I never made any recursive classes so I'm not sure ?

Also how am I able to detect if the same dice and side are "endlessly" referring to them self.

Like:

D1.CurrentSide = Side1; Side1.Dice = D1;

Should I check this when building objects ?

Edit:

• If D1 rolls S2 then D2 shouldn't be rolled. Also D2.Dice = Null.

• If D1 rolls S1 then D2 should be rolled.

• If D2 rolls S1 then D3 should be rolled.

• If D2 rolls S2 then D4 should be rolled.

D3 and D4 shouldn't trigger any roll.

Answer 1

What you are making is called a state machine. Your program (the "machine") is always in some state, but can change the state as a consequence of performing some action. Depending on the logic it can be quite acceptable that the machine can be in the same state more than once. So, I wouldn't bother too much about loops in the machine's logic. If a user wants the loop then let him have it, as long as the machine can reach some final state and program reaches the end of execution.

Answer 2

Based on what you've said, I suggest you to create an object graph of the dices, where one dice is connected through to the other dices and then run a topological sorting algorythm to reveal cyclic dependencies.

To do that I'd recommend either write it yourself, you use the QuickGraph tool.

Now, I myself did once use it and wrote an extension to the IEnumerable thing where it returns sorted IList in a way, where first items returned are the items never referenced by the other items. The latter are the most referenced. (Or mayhaps the other way around.) In case of cyclic dependencies the exception in thrown. My extension uses the QuickGraph library.

public static IList<T> OrderTopologically<T>(this IEnumerable<T> e, Func<T, IEnumerable<T>> dependenciesSelector)
{
    var graph = new AdjacencyGraph<T, Edge<T>>();

    foreach (T item in e)
    {
        graph.AddVertex(item);

        foreach (T dependecy in dependenciesSelector(item))
        {
            graph.AddEdge(new Edge<T>(item, dependecy));
        }
    }

    var topSort = new TopologicalSortAlgorithm<T, Edge<T>>(graph);

    try
    {
        topSort.Compute();
    }
    catch (NonAcyclicGraphException cyclicException)
    {
        throw new ElQueueException("Circular reference detected while processing javascript dependency order.", cyclicException);
    }
    catch (KeyNotFoundException keyNotFoundException)
    {
        throw new ElQueueException("Dependency could not be found.", keyNotFoundException);
    }

    return topSort.SortedVertices;
}