C#“继承”静态方法？

Question

这是我想要完成的示例：

abstract class DoSomething
{
    static void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You asked the abstract class to work. Too bad.");
    }
}

class InspireMe : DoSomething
{
    static void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You are amazing.");
    }
}

class InsultMe : DoSomething
{
    static void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You aren't worth it.");
    }
}

class Program
{
    static void Main()
    {
        DoSomething worker = InsultMe;
        worker.DoWhateverItIsThatIDo(); 

        worker = InspireMe;
        worker.DoWhateverItIsThatIDo();
    }
}

我来自 Python 背景，其中方法本身可以是一个变量，然后可以调用它。看起来 C# 没有这个概念，但我正在尝试完成类似的事情。

我的想法是我想要一个可以是抽象类型的变量，以便在其中可以存在许多不同类型的子类型。所有这些亚型都有一定的方法。我希望能够将这些子类型中的任何一个分配给这个抽象类型的变量，然后调用子类型中存在的 static 方法。

在 C# 术语中，我希望能够将 class 分配给变量，而不是类的 instance，然后调用该类的静态方法。

工厂听起来可能走在正确的道路上，但我不确定工厂本身如何能够生成对类的这些引用（而不是创建实例）。

我可以修改它以使用实例，但假设我想要生成每种类型的类的静态方法，所有这些仍然从基类型继承。

我觉得最有可能做到这一点 - 有人可以建议吗？

Answer 1

在您所描述的意义上，您不能将类用作 C# 中的变量。反射本质上允许您将类型视为变量并动态调用它们的静态成员，但它会很混乱并且不是类型安全的。

您可以通过使用单例模式基本上完成您想要做的事情：

interface IDoSomething
{
    void DoWhateverItIsThatIDo();
}

class DoSomething : IDoSomething
{
    private DoSomething() {}
    internal static readonly IDoSomething Instance;
    static DoSomething()
    {
        Instance = new DoSomething();
    }

    public void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You asked the abstract class to work. Too bad.");
    }
}

class InspireMe : IDoSomething
{
    private InspireMe() {}
    internal static readonly IDoSomething Instance;
    static InspireMe()
    {
        Instance = new InspireMe();
    }

    public void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You are amazing.");
    }
}

class InsultMe : IDoSomething
{
    private InsultMe() {}
    internal static readonly IDoSomething Instance;
    static InsultMe()
    {
        Instance = new InsultMe();
    }

    public void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You aren't worth it.");
    }
}

class Program
{
    static void Main()
    {
        IDoSomething worker = InsultMe.Instance;
        worker.DoWhateverItIsThatIDo(); 

        worker = InspireMe.Instance;
        worker.DoWhateverItIsThatIDo();
    }
}

Answer 2

C# 和 Java 都不能让您覆盖静态基类方法。

但是，您似乎仍然在使用对对象的引用（您的 worker 变量），那么为什么不直接使用非静态类方法呢？

（如果这不是您的本意，请澄清。）

Answer 3

我不是 100% 确定这是你想要的，但我写了一个模拟 Prototypal inheritance in C# 的库。

public class Foo: ProtoObject {}
public class Bar: Foo {}

dynamic myFoo = new Foo();
dynamic yourFoo = new Foo();
dynamic myBar = new Bar();

myFoo.Prototype.Name = "Josh";
myFoo.Prototype.SayHello = new Action(s => Console.WriteLine("Hello, " + s));

yourFoo.SayHello(myBar.Name); // 'Hello, Josh'

这当然涉及大量使用 dynamic 关键字，这可能没有用，因为您会丢失大量编译时间检查。

Answer 4

除了类和实例之外，您真正想要的是对具有特定签名的方法的引用，在您的情况下为 void ()。

虽然您不能将静态类分配给变量，但可以以类型安全的方式将方法分配给变量。在 C# 中，您通常会使用 Action 或 Func 的重载，具体取决于方法签名的外观。

为了让这更有趣，我们假设您想引用 int Foo(string, bool) 之类的东西，只需使用 Func<string,bool,int> 类型的变量并将具有此签名的任何方法分配给它。

解决您的问题的代码大致如下所示：

class DoSomething
{
    static void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You asked the abstract class to work. Too bad.");
    }
}

class InspireMe
{
    static void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You are amazing.");
    }
}

class InsultMe
{
    static void DoWhateverItIsThatIDo()
    {
        Console.WriteLine("You aren't worth it.");
    }
}

class Program
{
    static void Main()
    {
        Action worker = InsultMe.DoWhateverItIsThatIDo;
        worker(); 

        worker = InspireMe.DoWhateverItIsThatIDo;
        worker();
    }
}

Answer 5

解决方法可能是在基础抽象类中声明一个Action 类型的属性，该属性包含要调用的方法。然后在派生类实例化期间通过调用基类构造函数来初始化该属性：

abstract class DoSomething
{
    public Action DoWhateverItIsThatIDo { get; set; }

    protected DoSomething() { DoWhateverItIsThatIDo = DoSomething.DoIt; }

    protected DoSomething(Action whatAction)
    {
        DoWhateverItIsThatIDo = whatAction;
    }

    protected static void DoIt()
    {
        Console.WriteLine("You asked the abstract class to work. Too bad.");
    }
}

class InspireMe : DoSomething
{
    public InspireMe() : base(InspireMe.DoIt) { }

    private static void DoIt()
    {
        Console.WriteLine("You are amazing.");
    }
}

class InsultMe : DoSomething
{
    public InsultMe() : base(InsultMe.DoIt) { }

    private static void DoIt()
    {
        Console.WriteLine("You aren't worth it.");
    }
}

class DoWhatBaseClassDoes : DoSomething
{
    public DoWhatBaseClassDoes() : base() {}
}

class Program
{
    static void Main(string[] args)
    {
        DoSomething worker = new InsultMe();
        worker.DoWhateverItIsThatIDo();

        worker = new InspireMe();
        worker.DoWhateverItIsThatIDo();

        // In this case base class method is invoked
        worker = new DoWhatBaseClassDoes();
        worker.DoWhateverItIsThatIDo();
    }
}