子类型多态性，不向派生类添加依赖项

Question

Setup

Suppose I have a tree structure with nodes all deriving from abstract class FruitNode .

public abstract class FruitNode : Tree<FruitNode>
{
    public double NodeId { get; private set; }

    public FruitType Type { get; private set; }

    protected FruitNode(double nodeId, FruitType fruitType)
    {
        NodeId = nodeId;
        Type = fruitType;
    }

    public abstract double GetMagicalFruitValue();
}

All derived classes contain a method with which some additional fields on the derived class are set. These private fields are required to compute the magical fruit value.

For instance, a Banana derived class may look like this.

public class Banana : FruitNode
{
    private List<double> _bananaSecretValues;
    public Banana(double id) : base(id, FruitType.Banana) {}

    public void SetAdditionalBananaData2(List<double> computedBananaValues)
    {
        _bananaSecretValues = computedBananaValues;
    }

    public override double GetMagicalFruitValue()
    {
        return Math.Exp(_bananaSecretValues.Sum());
    }
}

And an Orange derived class.

public class Orange : FruitNode
{
    private List<double> _orangeSecretValueList1;
    private List<double> _orangeSecretValueList2; 

    public Orange(double id) : base(id, FruitType.Orange) {}

    public void SetAdditionalOrangeData(List<double> 
        computedList1Values, List<double> computedList2Values)
    {
        _orangeSecretValueList1 = computedList1Values;
        _orangeSecretValueList2 = computedList2Values;
    }

    public override double GetMagicalFruitValue()
    {
        return Math.Cos(_orangeSecretValueList1.Zip(_orangeSecretValueList2,
            (one, two) => one - two).Average());
    }
}

The question

The FruitNode tree is first set as a "skeleton", with none of the additional information on each node being set.

At some later stage in the program, I need to set the additional data on each node in the FruitNode tree. All of the additional data for the fruit nodes stems from the same object of type Economy .

The current solution is to loop over all of the nodes in the tree structure, and implement a switch on what the FruitType of the node is. The node is then cast to its corresponding derived class.

    public void SetAdditionalFruitTreeData(IEnumerable<FruitNode> nodesInFruitTree, Economy economy)
    {
        foreach (var node in nodesInFruitTree)
        {
            switch (node.Type)
            {
                case FruitType.Banana:
                {
                    List<double> computedBananaValues = new List<double>();

                    // do some manipulations with the economy to add values to
                    //    the computed banana values

                    // cast the node to the derived type Banana, and call
                    //    the SetAdditionalBananaData class 

                    break;
                }
                case FruitType.Orange:
                {
                    List<double> computedBananaValues = new List<double>();

                    // do some manipulations with the economy to add values to
                    //    the computed banana values

                    // cast the node to the derived type Orange, and call
                    //    the SetAdditionalOrangeData

                    break;
                }
                // continued for other fruit types
            }
        }
    }

But this is ugly . To me, this looks like a great use case for subtype polymorphism. I could add a

    public abstract void SetAdditionalData(Economy economy);

to the abstract base FruitType class, and then delegate the logic to each derived class itself to proceed with whatever calculations it needs from the Economy .

However , Economy is an external dependency from the FruitType tree classes, and I am not permitted to have the FruitType classes become dependent on the Economy class, which they evidently would become if I proceeded with the abstract method approach.

My question is , is there another way in which you can emulate polymorphic subtyping without adding a dependency in the subclasses on the parameters of the method in question?

---

^{My apologies for the possibly contrived example (I'm not very strong with OOP), if anything is unclear please do let me know and I will clarify accordingly.}

Answer 1

Implement an interface called IFruitNode which all fruit nodes implement. One of its methods would be SetAdditionalFruitTreeData . Your example Tree<FruitNode> would then be Tree<IFruitNode> and thus your existing SetAdditionalFruitTreeData would just loop all node and call the IFruitNode.SetAdditionalFruitTreeData() method. The FruitTree class would then have no dependency on the implementors of IFruitNode .