C#静态抽象方法替代方案：动物类命令解析实现问询

你遇到的核心问题是C#不支持静态抽象方法，导致无法通过基类约束子类实现统一的静态命令解析逻辑。以下是两种贴合需求的实现思路，均能满足遍历所有Animal子类判断动作支持性、新增子类仅需继承并定义动作的要求。

方案一：基于实例多态+单例注册表 #

利用非静态抽象方法实现多态，结合单例避免不必要的实例化，同时维护一个注册表统一管理所有Animal类型。

代码实现 #

// 动作基类不变
abstract class Action { }

class Roar : Action {
    public void DoTheRoar() { /* 吼叫逻辑 */ }
}
class Clap : Action {
    public void ClapFinsTogether() { /* 拍鳍逻辑 */ }
}
class Jump : Action {
    public void Jump() { /* 跳跃逻辑 */ }
}
class Fly : Action {
    public void TakeFlight() { /* 飞行逻辑 */ }
}

// 修改Animal基类，将静态抽象改为非静态抽象方法
abstract class Animal {
    public Action[] actionsToPerform;
    
    // 子类必须实现的命令解析方法
    public abstract bool InterpretCommand(string command, out Action outAction);
    
    // 子类返回自身单例的抽象方法
    public abstract Animal GetSingleton();
}

// Bear子类实现
class Bear : Animal {
    // 单例实例
    private static readonly Bear _instance = new Bear();
    public override Animal GetSingleton() => _instance;

    public override bool InterpretCommand(string command, out Action outAction) {
        if (command == "Roar") {
            outAction = new Roar();
            return true;
        }
        outAction = null;
        return false;
    }
}

// Seal子类实现
class Seal : Animal {
    private static readonly Seal _instance = new Seal();
    public override Animal GetSingleton() => _instance;

    public override bool InterpretCommand(string command, out Action outAction) {
        if (command == "Clap") {
            outAction = new Clap();
            return true;
        }
        if (command == "Jump") {
            outAction = new Jump();
            return true;
        }
        outAction = null;
        return false;
    }
}

// 新增Eagle子类示例
class Eagle : Animal {
    private static readonly Eagle _instance = new Eagle();
    public override Animal GetSingleton() => _instance;

    public override bool InterpretCommand(string command, out Action outAction) {
        if (command == "Fly") {
            outAction = new Fly();
            return true;
        }
        outAction = null;
        return false;
    }
}

// 动物注册表，统一管理所有Animal类型
public static class AnimalRegistry {
    public static readonly List<Animal> AllAnimals = new List<Animal>();

    static AnimalRegistry() {
        // 手动注册（小型项目推荐）
        AllAnimals.Add(Bear._instance);
        AllAnimals.Add(Seal._instance);
        AllAnimals.Add(Eagle._instance);

        // 反射自动注册（大型项目推荐，减少重复代码）
        // var animalTypes = AppDomain.CurrentDomain.GetAssemblies()
        //     .SelectMany(asm => asm.GetTypes())
        //     .Where(t => typeof(Animal).IsAssignableFrom(t) && !t.IsAbstract);
        // foreach (var type in animalTypes) {
        //     var instance = Activator.CreateInstance(type) as Animal;
        //     if (instance != null) AllAnimals.Add(instance);
        // }
    }

    // 查找所有支持指定命令的动物类型
    public static List<Type> FindAnimalsSupportingCommand(string command) {
        var result = new List<Type>();
        foreach (var animal in AllAnimals) {
            if (animal.InterpretCommand(command, out _)) {
                result.Add(animal.GetType());
            }
        }
        return result;
    }
}

使用示例 #

// 查找能飞的动物
var flyingAnimals = AnimalRegistry.FindAnimalsSupportingCommand("Fly");
foreach (var type in flyingAnimals) {
    Console.WriteLine($"{type.Name} can fly!"); // 输出：Eagle can fly!
}

// 解析Bear的吼叫命令
var bear = Bear._instance;
if (bear.InterpretCommand("Roar", out var roarAction)) {
    (roarAction as Roar)?.DoTheRoar();
}

方案二：静态命令映射+反射注册 #

通过子类静态字典存储命令与动作的映射，启动时用反射自动收集所有映射，无需实例化Animal即可完成命令解析。

代码实现 #

// 动作基类不变
abstract class Action { }

class Roar : Action {
    public void DoTheRoar() { /* 吼叫逻辑 */ }
}
class Clap : Action {
    public void ClapFinsTogether() { /* 拍鳍逻辑 */ }
}
class Jump : Action {
    public void Jump() { /* 跳跃逻辑 */ }
}
class Fly : Action {
    public void TakeFlight() { /* 飞行逻辑 */ }
}

// Animal基类无需抽象方法
abstract class Animal {
    public Action[] actionsToPerform;
}

// Bear子类定义静态命令映射
class Bear : Animal {
    public static readonly Dictionary<string, Func<Action>> CommandMap = new() {
        { "Roar", () => new Roar() }
    };
}

// Seal子类定义静态命令映射
class Seal : Animal {
    public static readonly Dictionary<string, Func<Action>> CommandMap = new() {
        { "Clap", () => new Clap() },
        { "Jump", () => new Jump() }
    };
}

// 新增Eagle子类示例
class Eagle : Animal {
    public static readonly Dictionary<string, Func<Action>> CommandMap = new() {
        { "Fly", () => new Fly() }
    };
}

// 命令解析注册表
public static class AnimalCommandRegistry {
    private static readonly Dictionary<Type, Dictionary<string, Func<Action>>> _typeCommandMaps = new();

    static AnimalCommandRegistry() {
        // 反射扫描所有Animal子类，收集静态CommandMap
        var animalTypes = AppDomain.CurrentDomain.GetAssemblies()
            .SelectMany(asm => asm.GetTypes())
            .Where(t => typeof(Animal).IsAssignableFrom(t) && !t.IsAbstract);

        foreach (var type in animalTypes) {
            var commandMapField = type.GetField("CommandMap", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
            if (commandMapField != null) {
                var commandMap = commandMapField.GetValue(null) as Dictionary<string, Func<Action>>;
                if (commandMap != null) _typeCommandMaps[type] = commandMap;
            }
        }
    }

    // 查找所有支持指定命令的动物类型
    public static List<Type> FindAnimalsSupportingCommand(string command) {
        return _typeCommandMaps.Where(kv => kv.Value.ContainsKey(command))
                               .Select(kv => kv.Key)
                               .ToList();
    }

    // 为指定动物类型解析命令
    public static bool InterpretCommand(Type animalType, string command, out Action outAction) {
        outAction = null;
        if (_typeCommandMaps.TryGetValue(animalType, out var map) && map.TryGetValue(command, out var factory)) {
            outAction = factory();
            return true;
        }
        return false;
    }
}

使用示例 #

// 查找能飞的动物
var flyingAnimals = AnimalCommandRegistry.FindAnimalsSupportingCommand("Fly");
foreach (var type in flyingAnimals) {
    Console.WriteLine($"{type.Name} can fly!"); // 输出：Eagle can fly!
}

// 解析Seal的拍鳍命令
if (AnimalCommandRegistry.InterpretCommand(typeof(Seal), "Clap", out var clapAction)) {
    (clapAction as Clap)?.ClapFinsTogether();
}

方案对比 #

内容的提问来源于stack exchange，提问作者Mr.P4L