为什么我不能声明C#方法虚拟和静态？

Question

我有一个辅助类,它只是一堆静态方法,并且想要辅助类的子类.某些行为是独特的,具体取决于子类,所以我想从基类调用虚方法,但由于所有方法都是静态的,我无法创建普通的虚方法(需要对象引用才能访问虚方法).

有没有办法解决？我想我可以使用单例.. HelperClass.Instance.HelperMethod()并不比HelperClass.HelperMethod()差.布朗尼指出任何可以指出支持虚拟静态方法的语言的人.

编辑:好的,我疯了.谷歌搜索结果让我觉得我不是那里的.

Answer 1

虚拟静态方法没有意义.如果我打电话HelperClass.HelperMethod();,为什么我会期望调用一些随机子类'方法？当你有2个子类时,解决方案真的会崩溃HelperClass- 你会使用哪一个？

如果你想拥有可重写的静态类型方法,你可能应该使用:

• 单例,如果您希望全局使用相同的子类.
• 传统类层次结构,具有工厂或依赖注入,如果您希望在应用程序的不同部分中使用不同的行为.

选择在您的情况下更有意义的解决方案.

Answer 2

我不认为你疯了.您只想使用.NET当前不可能的东西.

如果我们谈论泛型,那么您对虚拟静态方法的请求就会非常有意义.例如,我对CLR设计师的未来请求是允许我写这样的接口:

public interface ISumable<T>
{
  static T Add(T left, T right);
}

并像这样使用它:

public T Aggregate<T>(T left, T right) where T : ISumable<T>
{
  return T.Add(left, right);
}

但现在不可能,所以我这样做:

    public static class Static<T> where T : new()
    {
      public static T Value = new T();
    }

    public interface ISumable<T>
    {
      T Add(T left, T right);
    }

    public T Aggregate<T>(T left, T right) where T : ISumable<T>, new()
    {
      return Static<T>.Value.Add(left, right);
    }

Answer 3

实际上,这可以在Delphi中完成.一个例子:

type
  TForm1 = class(TForm)
    procedure FormShow(Sender: TObject);
  end;

  TTestClass = class
  public
    class procedure TestMethod(); virtual;
  end;

  TTestDerivedClass = class(TTestClass)
  public
    class procedure TestMethod(); override;
  end;

  TTestMetaClass = class of TTestClass;

var
  Form1: TForm1;

implementation

{$R *.dfm}

class procedure TTestClass.TestMethod();
begin
  Application.MessageBox('base', 'Message');
end;

class procedure TTestDerivedClass.TestMethod();
begin
  Application.MessageBox('descendant', 'Message');
end;


procedure TForm1.FormShow(Sender: TObject);
var
  sample: TTestMetaClass;
begin
  sample := TTestClass;
  sample.TestMethod;
  sample := TTestDerivedClass;
  sample.TestMethod;
end;

很有趣.我不再使用Delphi,但我记得能够使用元类特征在自定义设计器画布上轻松创建不同类型的控件:控件类,例如.TButton,TTextBox等是一个参数,我可以使用实际的元类参数调用适当的构造函数.

那种穷人的工厂模式:)

Answer 4

只需使用常规静态方法然后使用new关键字对其进行遮蔽即可达到相同的效果

public class Base 
{
    //Other stuff

    public static void DoSomething()
    {
        Console.WriteLine("Base");
    }
}

public class SomeClass : Base
{
    public new static void DoSomething()
    {
        Console.WriteLine("SomeClass");
    }
}
public class SomeOtherClass : Base
{
}

然后你可以调用这样的方法

Base.DoSomething(); //Base
SomeClass.DoSomething(); //SomeClass
SomeOtherClass.DoSomething(); //Base

Answer 5

我来自Delphi,这是我在c#中非常想念的很多功能.Delphi允许您创建类型化类型引用,并且您可以在需要父类类型的任何地方传递派生类的类型.这种对象类型的处理具有强大的实用性.特别是允许运行时确定元数据.我在这里混合语法非常糟糕,但在c#中它看起来像:

    class Root {
       public static virtual string TestMethod() {return "Root"; }
    }
    TRootClass = class of TRoot; // Here is the typed type declaration

    class Derived : Root {
       public static overide string TestMethod(){ return "derived"; }
    }

   class Test {
        public static string Run(){
           TRootClass rc;
           rc = Root;
           Test(rc);
           rc = Derived();
           Test(rc);
        }
        public static Test(TRootClass AClass){
           string str = AClass.TestMethod();
           Console.WriteLine(str);
        }
    } 

会产生:根源

Answer 6

静态方法存在于类的实例之外.它不能使用任何非静态数据.

虚拟方法将被重载函数"覆盖",具体取决于实例的类型.

所以你在静态和虚拟之间有明显的矛盾.

这不是支持问题,而是一个概念.

更新:我在这里被证明是错的(见评论):

所以我怀疑你会发现任何支持虚拟静态方法的OOP语言.

Answer 7

你并不疯狂.你所指的叫做Late Static Binding; 它最近被添加到PHP.有一个伟大的线程描述它 - 这里:你什么时候需要使用后期静态绑定？