Как лучше всего обеспечить вызов статического конструктора базового класса?

Здесь правила очень сложны, и между CLR 2.0 и CLR 4.0 они фактически изменено тонкими и интересными способами, из-за чего IMO делает наиболее" умные "подходы хрупкими между версиями CLR. Initialize() метод также может не выполнять работу в CLR 4.0, если он не касается полей.

Я бы поискал альтернативный дизайн или, возможно, использовал бы обычную ленивую инициализацию в вашем типе (т.е.проверьте немного или ссылку (против null), чтобы увидеть, было ли это сделано).

Вы можете вызвать статический конструктор explicity, поэтому вам не нужно будет создавать какие-либо методы для инициализации:

System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof (TypeBase).TypeHandle);

Вы можете вызвать его в статическом конструкторе производного класса.

Как отмечали другие, ваш анализ верен. Спецификация реализована здесь буквально; поскольку ни один член базового класса не был вызван и экземпляр не был создан, статический конструктор базового класса не вызывается. Я понимаю, как это может быть удивительно, но это строгая и правильная реализация спецификации.

У меня нет никаких советов, кроме «если тебе больно, когда ты это делаешь, не делай этого». Я просто хотел указать, что противоположный случай тоже может вас укусить:

class Program 
{
  static void Main(string[] args)
  {      
    D.M();
  }      

}
class B 
{ 
  static B() { Console.WriteLine("B"); }
  public static void M() {}
} 
class D: B 
{ 
  static D() { Console.WriteLine("D"); }
}

Это печатает «B», несмотря на то, что был вызван «член D». M является членом D исключительно по наследству; CLR не имеет возможности отличить, был ли B.M вызван «через D» или «через B».

Во время всего моего тестирования мне удавалось получить вызов только фиктивного члена на базе, чтобы база вызвала свой статический конструктор, как показано:

class Base
{
    static Base()
    {
        Console.WriteLine("Base static constructor called.");
    }

    internal static void Initialize() { }
}

class Derived : Base
{
    static Derived()
    {
        Initialize(); //Removing this will cause the Base static constructor not to be executed.
        Console.WriteLine("Derived static constructor called.");
    }

    public static void DoStaticStuff()
    {
        Console.WriteLine("Doing static stuff.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Derived.DoStaticStuff();
    }
}

Другой вариант заключался в включении статического члена, доступного только для чтения, в производный тип, который выполнял следующие действия:

private static readonly Base myBase = new Base();

Однако это похоже на взлом (хотя и фиктивный член тоже), чтобы вызвать базовый статический конструктор.

Я почти всегда жалею, что полагаюсь на что-то подобное. В дальнейшем статические методы и классы могут вас ограничить. Если вы позже захотите закодировать какое-то особое поведение для своего класса Type, вы окажетесь в коробке.

Итак, вот небольшой вариант вашего подхода. Это немного больше кода, но он позволит вам позже определить настраиваемый тип, который позволит вам делать настраиваемые вещи.

    abstract class TypeBase
    {
        private static bool _initialized;

        protected static void Initialize()
        {
            if (!_initialized)
            {
                Type<int>.Instance = new Type<int> {Name = "int"};
                Type<long>.Instance = new Type<long> {Name = "long"};
                Type<double>.Instance = new Type<double> {Name = "double"};
                _initialized = true;
            }
        }
    }

    class Type<T> : TypeBase
    {
        private static Type<T> _instance;

        public static Type<T> Instance
        {
            get
            {
                Initialize();
                return _instance;
            }
            internal set { _instance = value; }
        }

        public string Name { get; internal set; }
    }

Позже, когда вы доберетесь до добавления виртуального метода в Type и захотите специальной реализации для Type, вы можете реализовать его следующим образом:

class TypeInt : Type<int>
{
    public override string Foo()
    {
        return "Int Fooooo";
    }
}

А затем подключите его, изменив

protected static void Initialize()
{
      if (!_initialized)
      {
          Type<int>.Instance = new TypeInt {Name = "int"};
          Type<long>.Instance = new Type<long> {Name = "long"};
          Type<double>.Instance = new Type<double> {Name = "double"};
          _initialized = true;
       }
}

Я бы посоветовал избегать статических конструкторов - это легко сделать. Также избегайте статических классов и, где возможно, статических членов. Я не говорю никогда, просто умеренно. Предпочитайте синглтон класса статическому.

Просто идея, вы можете сделать что-то вроде этого:

    abstract class TypeBase
    {
        static TypeBase()
        {
            Type<int>.Name = "int";
            Type<long>.Name = "long";
            Type<double>.Name = "double";
        }
    }

    class Type<T> : TypeBase
    {
        static Type() 
        {
            new Type<object>();
        }

        public static string Name { get; internal set; }
    }

    class Program
    {
        Console.WriteLine(Type<int>.Name);
    }