在 C# 中使用 GetType/instanceof 与替代方案

Question

我在使用 C# 制作的游戏中遇到了问题。这是一个简单的基于图块的匹配游戏，而我正在尝试制作的电源出现问题：

假设我们有基本的瓷砖类型，圆形、正方形和菱形，它们都是 Tile 的子类。我尝试将“匹配”行为提取到抽象的 Tile 方法：canMatchWith(Tile t)，而不是让圆圈只匹配圆圈。 Tiles 也有两种方法来添加/删除它们可以匹配的 Tiles。

假设我们在游戏中间有一个圆形图块，并且我们有一个通电，上面写着“圆形图块可以在本回合与正方形图块匹配”。我会遍历所有圆形图块并说 circleTile.addCanMatchWith(typeof(Square))。在内部，我们有一个 List canMatchWith。

然后，我想说“圆不能再与正方形匹配”，简单地说 circleTile.removeCanMatchWith(typeOf(Square))。

这是我目前的解决方案，它运行良好，没有我注意到的性能缺陷（这是一个基于图块的匹配游戏，因此这些类型每次“移动”只评估一次，而不是逐帧评估）。但是，我脑海中的声音告诉我，这是完成此行为的不好方法。所以我有一些选择：

1. 枚举... 每个 Tile 可以由 Tiletype 类型变量组成。这将在构造函数中初始化并设置为 Type.SQUARE 用于正方形，依此类推。然后，每个 Tile 都会有一个 List canMatchWith，功能和我原来的实现是一样的。除了在这种情况下，它有点棘手。假设我有一些圆形子类，椭圆形和椭圆形。我希望椭圆只能匹配正方形，但椭圆可以匹配所有圆圈而不是正方形。

这里的问题是冗余，我的枚举现在也将具有 OVAL 和 ELIPSE，并且 Elipse 类将具有 (CIRCLE, OVAL, ELIPSE TileTypes) 作为它可以匹配的类型。这完全是多余的，我只想说“圆圈”，我可以用这些类型。我想 Tiles 可能有 TileType baseType 和 TileType actualType。

1. 某种形式的行为组合。忘记 Tile 子类，只需给 Tiles 方法和 List 的实例变量。然后，在运行时我们可以说 someTile.addCanMatch(new CircleMatchBehavior())。这似乎很愚蠢，因为我会有一堆课程只是说你可以匹配特定的形状。

总之，我想要完成的是让多个对象类型能够与任意数量的不同类型进行交互。问题是，我应该为 Type 使用什么。这里可以使用 GetType 吗？枚举？还是有人会推荐更好的策略？我试图尽可能笼统，这些图块不应该对其他图块有任何硬编码依赖，并且必须能够随时更改它们可以与之交互的对象。假设我创建了一个新的 Tile 子类 pentagon... 嗯，Pentagons 可以与 Squares、Circles 和 Pentagons 匹配。我的实现很容易，但有些事情告诉我这是一种肮脏的 OOP 实践。

我觉得我必须使用类型/枚举，因为我不想说 thisTile.addCanMatch(Tile someOtherObject)。这太具体了，我希望 thisTile 能够与作为特定类实例的所有图块匹配。

Answer 1

我知道这个问题已经被回答和接受了，但是我曾经做过一次这样的事情，我想我应该在这里发布代码。

    public class TypeMatchManager
    {
        private Dictionary<Type, List<Type>> savedMatches = new Dictionary<Type, List<Type>>();

        public TypeMatchManager() { }

        public void AddMatch(Type firstType, Type secondType)
        {
            this.addToList(firstType, secondType);
            this.addToList(secondType, firstType);
        }

        public void DeleteMatch(Type firstType, Type secondType)
        {
            this.deleteFromList(firstType, secondType);
            this.deleteFromList(secondType, firstType);
        }

        public bool CanMatch(Type firstType, Type secondType)
        {
            List<Type> firstTypeList = this.findListForType(firstType);
            List<Type> secondTypeList = this.findListForType(secondType);
            return (firstTypeList.Contains(secondType) || secondTypeList.Contains(firstType));
        }

        private void addToList(Type firstType, Type secondType)
        {
            var matchingTypes = this.findListForType(firstType);
            if (!matchingTypes.Contains(secondType))
            {
                matchingTypes.Add(secondType);
            }
        }

        private void deleteFromList(Type firstType, Type secondType)
        {
            var matchingTypes = this.findListForType(firstType);
            if (matchingTypes.Contains(secondType))
            {
                matchingTypes.Remove(secondType);
            }
        }

        private List<Type> findListForType(Type type)
        {
            foreach (var keyValuePair in savedMatches)
            {
                if (keyValuePair.Key == type)
                {
                    return keyValuePair.Value;
                }
            }
            savedMatches.Add(type, new List<Type>());
            return findListForType(type);
        }
    }

该类的设计使您提供哪种类型的参数无关紧要；它检查 type1.list 有 type2 和 type2.list 有类型。

一个简单的例子：

        typeManager.AddMatch(a, b);
        Console.WriteLine(typeManager.CanMatch(a, b)); // True
        typeManager.DeleteMatch(b, a);
        Console.WriteLine(typeManager.CanMatch(a, b)); // False
        Console.WriteLine(typeManager.CanMatch(a, c)); // False
        typeManager.AddMatch(a, c);
        Console.WriteLine(typeManager.CanMatch(a, c)); // True
        Console.WriteLine(typeManager.CanMatch(a, d)); // False
        typeManager.AddMatch(b, d);
        Console.WriteLine(typeManager.CanMatch(a, d)); // False
        Console.WriteLine(typeManager.CanMatch(d, b)); // True
        typeManager.DeleteMatch(d, b);
        Console.WriteLine(typeManager.CanMatch(d, b)); // False
        Console.WriteLine(typeManager.CanMatch(b, d)); // False

Answer 2

如果类似类型的所有形状总是共享一个行为，那么不将该行为存储在“每个实例”级别上是有意义的。相反，您可以拥有一个“CanMatchManager”，它存储按形状类型索引的列表字典。然后，当一个圆圈尝试比较匹配时，它会从 MatchManager 请求它可以匹配的类型。或者，MatchManager 可以接收两个形状，并确定它们是否匹配。这是Mediator Pattern