C#如何从子类调用静态方法

我有以下代码：

class Super{ 
   public static List<Super> methodA() { . . . }
}
class Sub:Super{ 
   public static List<Sub> methodA() { . . . }
}

但是执行的是超类。无论如何，我可以执行子类的静态方法吗？它们具有相同的静态方法名称

更新：

---

你们可以看到产品是我的超类，购买是子类。两者都有相同的静态getAll（），但返回的类型不同。在这种情况下，它返回的列表

在子类中使用的方法名与超类中提供的方法名相同，您必须重写它-但是对于C#中的静态方法是不可能的

请看一看这篇文章，它为该主题提供了很好的内部信息：

---

子类中的方法A

将在基类中隐藏该方法。因此

Sub.methodA

将调用Sub类中的方法，而不是基类

Sub.MethodA（）隐藏继承的成员Super.MethodA（）。如果要隐藏，请使用新关键字

Super.methodA（）

将从任何位置调用super的静态方法。。。来自超级类，来自子类，来自两个类之外，等等

Sub.methodA（）将从任何位置调用sub的静态方法

以下是我的测试代码：

class Program
{
    class Super
    {
        public static List<Super> methodA() { Console.WriteLine("SUPER"); return new List<Super>(); }

        public void callSuper()
        {
            Super.methodA();
        }

        public void callSub()
        {
            Sub.methodA();
        }
    }
    class Sub : Super
    {
        public static List<Sub> methodA() { Console.WriteLine("SUB"); return new List<Sub>(); }

        public void callSuper()
        {
            Super.methodA();
        }

        public void callSub()
        {
            Sub.methodA();
        }
    }

    static void Main(string[] args)
    {
        Super.methodA();

        Sub.methodA();

        var s = new Sub();
        s.callSuper();
        s.callSub();

        var Sup = new Super();
        Sup.callSuper();
        Sup.callSub();

        Console.ReadLine();
    }
}

类程序
{
超级班
{
公共静态列表方法A（）{Console.WriteLine（“SUPER”）；返回新列表（）；}
公共无效callSuper（）
{
Super.methodA（）；
}
公开作废callSub（）
{
Sub.methodA（）；
}
}
组别：超级
{
公共静态列表方法A（）{Console.WriteLine（“SUB”）；返回新列表（）；}
公共无效callSuper（）
{
Super.methodA（）；
}
公开作废callSub（）
{
Sub.methodA（）；
}
}
静态void Main（字符串[]参数）
{
Super.methodA（）；
Sub.methodA（）；
var s=新的子对象（）；
s、 callSuper（）；
s、 callSub（）；
var Sup=new Super（）；
Sup.callSuper（）；
Sup.callSub（）；
Console.ReadLine（）；
}
}
此功能按预期工作，请参见下面的示例（）。你的示例代码和真实代码之间有点不对劲

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Sub.methodA());
        Console.WriteLine(Super.methodA());
    }
}
class Super{ 
   public static List<Super> methodA() { return new List<Super>(); }
}
class Sub:Super{ 
   public new static List<Sub> methodA() { return new List<Sub>(); }
}

公共类程序
{
公共静态void Main（）
{
Console.WriteLine（Sub.methodA（））；
Console.WriteLine（Super.methodA（））；
}
}
类超级{
公共静态列表方法A（）{返回新列表（）；}
}
子类：超级{
public new static List methodA（）{return new List（）；}
}
只需使用类型名称调用它们：

 Sub.methodA();
 Super.methodA();

静态方法仅存在于声明它的类中。它不能被继承，也不能在类的实例上调用

class Super
{
    public static char methodA() 
    {
        return 'a'; 
    }
}
class Sub : Super
{
    public static char methodA() 
    {
        return 'b'; 
    }
}

class Program
{
    static void Main(string[] args)
    {
        var res = Sub.methodA();
        var res2 = Super.methodA();

        Console.WriteLine(res == res2);

        Console.ReadKey();
}

输出：
false
这称为“隐藏”，而不是“覆盖”。虽然不推荐，但它确实有效。如果调用Super.MethodA，它将在基类上运行该方法。如果运行Sub.MethodA，它将在派生类中运行该方法。我刚刚证实这是100%确定的

你可能想在这里重新考虑你的设计。如果只是想让某人获得你的对象列表，而不必每次都新建一个类，那么有很多不同的方法可以做到这一点，而不需要隐藏。一些实现细节可能有助于我们提出有效的方法
 实际上，
Sub.methodA（）
将从子类执行静态方法并尝试它，但不是从子类的方法调用，而是调用了超类的方法。@user2936719您的示例与实际代码无关，或者您缺少了一些东西。但实际上-
Sub.methodA（）
在你展示的代码中，它会调用Sub方法，而不会调用super方法。@用户2936719，那么你就做错了，因为
Sub.methodA（）
只能在
Sub
中调用
methodA
。你肯定做错了什么。调用应该执行
Sub.methodA（）
而不是
Super.methodA（）
，如果您想确保您正在使用
Sub
的实现创建一个新方法，请通过将编辑内容与原始问题进行比较，向静态方法添加一个
new
关键字，我得到的印象是，当你把你的测试示例放在一起时，有些东西丢失了，而我们并没有得到你问题的全貌。当我的测试代码（上面）编译时没有错误或警告，我感到震惊。。。因此，这告诉我您的问题与Super和Sub无关。如果您仍然有问题，我建议您将方法重命名为GetAllProducts和GetAllBurchases。如果您重命名这些方法，即使只是暂时重命名，也可能会更容易找到您的问题。通过查看您的编辑，我怀疑您的一个声明可能不正确，但我不确定，因为我们没有完整的图片。嘿，用户2936719，选择我的答案。。。我需要积分！！只是开玩笑（或者我是？）。这个问题的最终结果是什么？
class Super
{
    public static char methodA() 
    {
        return 'a'; 
    }
}
class Sub : Super
{
    public static char methodA() 
    {
        return 'b'; 
    }
}

class Program
{
    static void Main(string[] args)
    {
        var res = Sub.methodA();
        var res2 = Super.methodA();

        Console.WriteLine(res == res2);

        Console.ReadKey();
}