C＃替代虚拟静态方法和静态子类

Question

每当我读到RE或者静态继承的类似主题时，答复通常都不支持（我们知道这一点），并且给出原因是因为这是一个糟糕的设计，可能有更好的方法来做到这一点。我很想找到一个更好的方式来做这件事，所以我愿意接受所有的建议 - 这就是我正在做的。

我有一个没有实例数据的类。所有的方法都是静态的。我们称之为class BaseStatic。我现在想要一个新的静态类（当然好几个，但让我们坚持一个）继承这个静态类并添加一些新的静态方法，我们称之为SubStatic。

我希望消费者能写的是：

SubStatic.MethodFromSub(); 

也

SubStatic.MethodFromBase(); 

我知道我也可以这样写：

BaseStatic.MethodFromBase() 

明确，但随后消费者知道哪些类实现了哪些方法。我不能用继承来做到这一点，因为我不能从另一个静态类继承。那么做一个更好的方法是什么？

现在，我知道我能有这些类的实例类，我可以定义的所有方法静态 - 这会给我我上述的行为，但会导致其他问题，即：

1. 当我这样做：SubStatic.MethodFromBase()因为该方法是在父静态类运行（父的静态构造函数被调用）

2. 如果静态父方法之一，需要调用其它方法SubStatic静态构造函数不叫哪子类可以覆盖，我需要一个虚拟的静态方法在子类中。我知道我不能拥有。

这么差的设计显然 - 任何人都可以帮我重做吗？我知道我可以使用实例继承并正确使用虚拟方法（我以这种方式工作），但客户端代码总是需要创建一个实例（或者我想某个单例）。

Answer 1

这可以达到你的目的，但我肯定会包括一些异常处理，并伴随它的实现，并附有大量关于它为什么以及如何工作的文档。

当Base的静态构造函数运行（一次）时，编目当前加载到应用程序域中的所有程序集，并选择从Base派生的类型。迭代这些，我们运行静态构造函数。值得注意的是，这不再保证每个实现的cctor只会运行一次，必须添加逻辑才能重新做出该断言。此外，对于该Base cctor已运行后，可以进行装载的类型将不被调用在Base

初始化方法来模拟虚拟方法，使用new关键字隐藏基方法。您可以通过（在本例中B类等）与声明类的名称限定它

using System; 
using System.Linq; 
using System.Runtime.CompilerServices; 

namespace ConsoleApplication6 
{ 
    public class Base 
    { 
     static Base() 
     { 
      Console.WriteLine("Base cctor"); 

      var thisType = typeof (Base); 
      var loadedTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()); 
      var derivations = loadedTypes.Where(thisType.IsAssignableFrom); 

      foreach(var derivation in derivations) 
      { 
       RuntimeHelpers.RunClassConstructor(derivation.TypeHandle); 
      } 
     } 

     public static void Foo() 
     { 
      Console.WriteLine("Bar"); 
     } 
    } 

    public class A : Base 
    { 
     static A() 
     { 
      Console.WriteLine("A cctor"); 
     } 
    } 

    public class B : Base 
    { 
     static B() 
     { 
      Console.WriteLine("B cctor"); 
     } 

     public new static void Foo() 
     { 
      Console.WriteLine("Bar!!"); 
      Base.Foo(); 
     } 
    } 

    class Program 
    { 
     static void Main() 
     { 
      Console.WriteLine("A:"); 
      A.Foo(); 
      Console.WriteLine(); 
      Console.WriteLine("B:"); 
      B.Foo(); 
      Console.WriteLine(); 
      Console.WriteLine("Base:"); 
      Base.Foo(); 
      Console.ReadLine(); 
     } 
    } 
} 

编辑调用基方法

另一种选择在于CRTP（或CRGP在C＃范例），或好奇地重复模板（通用）参数模式

using System; 
using System.Runtime.CompilerServices; 

namespace ConsoleApplication6 
{ 
    public class Base<T> 
     where T : Base<T> 
    { 
     static Base() 
     { 
      RuntimeHelpers.RunClassConstructor(typeof (T).TypeHandle); 
     } 

     public static void Foo() 
     { 
      Console.WriteLine("Bar"); 
     } 
    } 

    public class Base : Base<Base> 
    { 
    } 

    public class A : Base<A> 
    { 
     static A() 
     { 
      Console.WriteLine("A cctor"); 
     } 
    } 

    public class B : Base<B> 
    { 
     static B() 
     { 
      Console.WriteLine("B cctor"); 
     } 

     public new static void Foo() 
     { 
      Console.WriteLine("Bar!!"); 
      Base<B>.Foo(); 
     } 
    } 

    class Program 
    { 
     static void Main() 
     { 
      Console.WriteLine("A:"); 
      A.Foo(); 
      Console.WriteLine(); 
      Console.WriteLine("B:"); 
      B.Foo(); 
      Console.WriteLine(); 
      Console.WriteLine("Base:"); 
      Base.Foo(); 
      Console.ReadLine(); 
     } 
    } 
} 

在这种情况下，当我们调用静态方法上A我们真正调用它Base<A>这是不同于Base<B>或Base因此我们可以实际上确定如何调用该方法并运行适当的cctor。

Answer 2

您可以通过使用泛型来实现此目的。例如，您可以使用类似的东西：

public class MainStatic<T> where T : MainStatic<T> 
{ 
    public static void Foo() 
    { 
    } 

    static MainStatic() 
    { 
     RuntimeHelpers.RunClassConstructor(typeof(T).TypeHandle); 
    } 
} 

public class SubStatic : MainStatic<SubStatic> 
{ 
    public static void Bar() 
    { 
    } 
} 

public class Instance 
{ 
    public void FooBar() 
    { 
     SubStatic.Foo(); 
     SubStatic.Bar(); 
    } 
}