这种总体设计模式有名称吗？

Question

I frequently find myself using the following pattern when I want to avoid using large switch statements (please excuse the hackneyed 'animal' theme):

public enum AnimalType { Dog, Cat, Hamster }

public interface IAnimal
{
    AnimalType AnimalType { get; }
}

public class Cat : IAnimal
{
    public AnimalType AnimalType { get { return AnimalType.Cat; } }
}

public class AnimalAggregator
{
    private readonly IDictionary<AnimalType, IAnimal> _animals;

    public AnimalAggregator(IEnumerable<IAnimal> animals)
    {
        _animals = animals.ToDictionary(a => a.AnimalType);
    }

    public IAnimal Get(AnimalType animalType)
    {
        IAnimal animal;
        return _animals.TryGetValue(animalType, out animal) ? animal : null;
    }
}

In the above example I would take a dependency on AnimalAggregator and allow an IoC container to wire up the injection of all IAnimal s. Then instead of writing out a large switch statement for retrieving the IAnimal associated with AnimalType.Cat , I just call animalAggregator.Get(AnimalType.Cat) .

I have used this pattern (and variations thereof) many times in my projects but never known what to call it - I tend to go with "aggregator" but I'm not sure that's accurate. I have never seen it outside of my own code though.

Does it have a name?

Answer 1

This feels to me like it should be an abstract factory pattern:

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

You will then have an AnimalFactory with different GetMethods for each animal type. I guess you could have a generic get method but this defeats the purpose of the abstract factory. Since you are in any way limited by the enum why not have a method per type.

For more info see http://www.dofactory.com/Patterns/PatternAbstract.aspx

Answer 2

I think this is just a variation of the abstract factory pattern. The only thing left to do is make AnimalAggregator extend an IAnimalFactory interface and change client code to take a dependency on IAnimalFactory instead of AnimalAggregator .

public inteface IAnimalFactory
{
    IAnimal Get(AnimalType t);
}