title: How to trigger a static constructor
body: <p>code:</p>
  
  <pre><code>class Base&lt;T,U&gt; where T:Base&lt;T,U&gt;,new()  where U :class
  {
      protected static U _val = null;
      internal static void ShowValue()
      {
          if(_val == null)new T(); //Without this line, it won't work as expected
          Console.WriteLine (_val);
      }
      internal static void Virtual()
      {
          Console.WriteLine ("Base");
      }
  }
  class Deriv :Base&lt;Deriv,string&gt;
  {
      static Deriv()
      {
          _val = "some string value";
      }
      internal static new void Virtual ()
      {
          Console.WriteLine ("Deriv");
      }
  }
   public static void Main (string[] args)
  {
      Deriv.ShowValue();            
      Deriv.Virtual();
  }
  </code></pre>
  
  <p>Thanks to the generics of .NET, I can create a bunch of specific classes reusing generic static methods defined  in the generic base class. It can mimic inheritance polymorphism to some extent. But in order to initialize different version of static fields, I've to use static constructors. Unfortunately, we can't call them directly, therefore, we have to figure out a way to trigger it's invocation. The example given above showed a way. But I don't like either the instantiation,or the reflection approach. We also can't make a constraint on a static method of a generic parameter. So, I'd like to ask, if there is another way to do this kind of job! </p>
  
  <p>Thanks beforehand!</p>
  
  <p>~~~~~~~~~~~~~~~~</p>
  
  <p><strong>Some Conclusion</strong> (Maybe a little early):</p>
  
  <p>It seems there is no workaround to deal with this kind of situation. I have to instantiate a subclass or use reflection. Considering  the .cctors need merely be called once, I'm in favor of the reflection approach, because in some case, a new() constraint is just not a choice - like you're not supposed to expose the parameterless ctor to user. </p>
  
  <p>After conducting further experiment, I find out that the .cctors may be called multi-times but only the first invocation will affect the setting of static fields. That's weird, but a good weirdness!</p>
  
  <pre><code>    class MyClass 
      {
          static int _val = 0;
          static MyClass()
          {
              _val++;
              Console.WriteLine (_val);
          }
      }
      public static void Main (string[] args)
      {
          ConstructorInfo ci = typeof(MyClass).TypeInitializer;
          ci.Invoke(new object[0]);
          ci.Invoke(new object[0]);
          ci.Invoke(new object[0]);
      }
  //result:
  //1
  //1
  //1
  //1
  </code></pre>