如何改变这种设计以避免沮丧？

Question

假设我有一个全部继承自基类的对象集合。 就像……

   abstract public class Animal
    {

    }

    public class Dog :Animal
    {

    }

    class Monkey : Animal
    {

    }

现在，我们需要喂养这些动物，但不允许它们知道如何喂养自己。 如果他们可以，答案会很简单：

foreach( Animal a in myAnimals )
{
   a.feed();
}

但是，他们不知道如何养活自己，所以我们想做这样的事情：

    class Program
{
    static void Main(string[] args)
    {
        List<Animal> myAnimals = new List<Animal>();

        myAnimals.Add(new Monkey());
        myAnimals.Add(new Dog());

        foreach (Animal a in myAnimals)
        {
            Program.FeedAnimal(a);
        }
    }

    void FeedAnimal(Monkey m) {
        Console.WriteLine("Fed a monkey.");
    }

    void FeedAnimal(Dog d)
    {
        Console.WriteLine("Fed a dog.");
    }

}

当然，这不会编译，因为这会迫使他们沮丧。

感觉好像有一种设计模式或其他一些泛型解决方案可以帮助我解决这个问题，但我还没有付诸实践。

建议？

Answer 1

Linq 惯用法中使用的检查型向下转型是完全安全的。

foreach (Monkey m in myAnimals.OfType<Monkey>())
    Program.FeedAnimal(m);

或者您可以使用访客模式。 访问者对象知道所有类型的动物，因此它为每种动物都有一个 FeedAnimal 函数。 您将访问者对象传递给动物的 Feed 函数，它会回调到正确的 FeedAnimal 方法，并传递 this。

为了使其可扩展，您需要一个动物喂食器的字典：

private static Dictionary<Type, Action<Animal>> _feeders;

要注册喂食动作，您首先需要这样做：

_feeders[typeof(Monkey)] = 
    a =>
    {
        Monkey m = (Monkey)a;

        // give food to m somehow
    };

但是有一个向下的类型，您必须在钥匙也是如此。 因此，制作一个助手：

public static void AddFeeder<TAnimal>(Action<TAnimal> feeder) where TAnimal : Animal
{
    _feeders[typeof(TAnimal)] = a => feeder((TAnimal)a);
}

这会捕获模式，以便您可以完全安全地重用它：

AddFeeder<Monkey>(monkey => GiveBananasTo(monkey));
AddFeeder<Dog>(dog => ThrowBiscuitsAt(dog));

然后，当您需要喂养动物时，请使用此扩展方法：

public static void Feed(this Animal a)
{
    _feeders[a.GetType()](a);
}

例如，

a.Feed();

因此 _feeders 将是与扩展方法相同的静态类中的私有静态字段，以及 AddFeeder 方法。

更新：所有代码都集中在一个地方，还支持继承：

public static class AnimalFeeding
{
    private static Dictionary<Type, Action<Animal>> _feeders 
        = new Dictionary<Type, Action<Animal>>();

    public static void AddFeeder<TAnimal>(Action<TAnimal> feeder) 
        where TAnimal : Animal
    {
        _feeders[typeof(TAnimal)] = a => feeder((TAnimal)a);
    }

    public static void Feed(this Animal a)
    {
        for (Type t = a.GetType(); t != null; t = t.BaseType)
        {
            Action<Animal> feeder;
            if (_feeders.TryGetValue(t, out feeder))
            {
                feeder(a);
                return;
            }
        }

        throw new SystemException("No feeder found for " + a.GetType());
    }
}

您还可以循环遍历每种类型 t 支持的接口 - 基本上是相同的想法，所以我这里的例子保持简单。

Answer 2

这是OOD中的一个经典问题。 如果您的类（动物）集是固定的，则可以使用访问者模式。 如果您的一组操作（例如 feed）受到限制，您只需向 Animal 添加一个 feed() 方法。 如果这些都不成立，就没有简单的解决方案。

Answer 3

首先，面向对象设计的要点之一是对象将其数据与作用于该数据的行为捆绑在一起（即“动物知道如何喂养自己”）。 所以这是“医生，当我这样做时会很痛！ - 所以不要那样做”的情况之一。

也就是说，我确信这个故事比您所描述的更多，并且您有充分的理由无法进行“适当的”OOD。 所以你有几个选择。

您可以让 FeedAnimal(Animal a) 方法使用反射来查找动物的类型。 基本上，您是在 FeedAnimal 方法中进行多态性。

static void FeedAnimal(Animal a)
{
    if (a is Dog)
    {
        Console.WriteLine("Fed a dog.");
    }
    else if (a is Monkey)
    {
        Console.WriteLine("Fed a monkey.");
    }
    else
    {
        Console.WriteLine("I don't know how to feed a " + a.GetType().Name + ".");
    }      
}

一种更面向对象但更复杂的方法是使用其他人建议的访问者模式。 这对于经验丰富的开发人员来说更加优雅，但对于更多的新手程序员来说可能不太明显和可读。 您喜欢哪种方法可能取决于您有多少种不同的动物类型。

Answer 4

仅当您有一个“狗列表”并且想要调用一个参数为“动物列表”的方法时，泛型才有用（即 List其中 T : Animal ） - 我认为这没有帮助。

我怀疑您将需要一个访问者模式...一些对象可能知道如何喂养特定类型的动物，并不断尝试，直到找到一个知道如何喂养的动物......

Answer 5

由于不允许动物喂养自己或其他动物，因此您别无选择，然后创建一个“所有者”或“饲养员”或“看护者”类，他们拥有喂养动物的私有方法。

Answer 6

您可以在动物类中包含一个成员变量，该变量将识别动物的类型，然后让 feed 函数读取它并根据它生成不同的结果。