静态构造函数调用两次

Question

Previously I've had a static TopUp() method what I wanted to substitute with the Baseclass's static constructor, because it's "performed once only" as the msdn states.
msdn: Static Constuctor
Any solution for keep the derived classes' initialization in the constructor and perform it only once?

class BaseClass<T>
{
    static BaseClass()
    {
        for (byte i = 0; i < 2; i++)
        {
            var temp = new Junction<byte>[2] { new Level2<byte>(), new OtherLevel2<byte>() };
            Program.myList.Add(temp);
        }
        Console.WriteLine("static BaseClass()");
    }
}

abstract class Junction<T> : BaseClass<T> { }

sealed class Level2<T> : Junction<T> { }

sealed class OtherLevel2<T> : Junction<T> { }

class Program
{
    internal static List<Junction<byte>[]> myList = new List<Junction<byte>[]>();
    static Program()
    {
        BaseClass<object> callTheStaticMethod = new BaseClass<object>();
    }

    static void Main()
    {
        Console.WriteLine("myList.Count = " + myList.Count);
        Console.ReadLine();
    }
}

Output:  
static BaseClass()  
static BaseClass()  
myList.Count = 4

Answer 1

Your static construction is called only once. Once per type, that is.

Each time you use your BaseClass<T> with a different type parameter, that's a completely different type. So, Junction<byte> , which inherits BaseClass<byte> , is a different type from BaseClass<object> . The static constructor for BaseClass<byte> is called, as well as the static constructor for BaseClass<object> .

It's not really clear from your question what it is you're actually trying to achieve. I will say, that the use of Junction<byte> in the static constructor strongly suggests that your class is not really generic at all. Any other use of BaseClass<T> is necessarily still dependent on Junction<byte> , and thus BaseClass<byte> . And this probably negates whatever benefit you thought you were going to get by making the class generic.

You can force the static constructor to execute only once by moving it to a non-generic base class inherited by BaseClass<T> . Eg:

class BaseClass { /* static constructor here */ }
class BaseClass<T> : BaseClass { /* other stuff */ }

But given the lack of generic-ness in the class to start with, it's not clear that this will really help much. There seems to be a broader design flaw here that should be addressed.

Answer 2

The issue is that you have the static initializer in a typed base class. The issue is that BaseClass<string> and BaseClass<int> are considered two different types. The actual classes are generated at compile time, and so the compiler duplicates the static initializer for each variation.

If you change the last line in the static initializer to include the name of the type you'll be able to get a better idea of this issue.

In .Net 4.6 you can do this:

Console.WriteLine($"static BaseClass<{nameof(T)}>()");

In .Net 4.0 or later you can do this:

string typeName = typeof(T).FullName;
Console.WriteLine(string.Format("static BaseClass<{0}>()", typeName));

To resolve your issue, do your static initialization in a standard class that does not have a type parameter. In this case, you can simply remove the <T> type parameter from the BaseClass. Example:

class BaseClass
{
    static BaseClass()
    {
        for (byte i = 0; i < 2; i++)
        {
            var temp = new Junction<byte>[2] { new Level2<byte>(), new OtherLevel2<byte>() };
            Program.myList.Add(temp);
        }

        Console.WriteLine($"static BaseClass<{nameof(T)}>()");
    }
}

abstract class Junction<T> : BaseClass { }

sealed class Level2<T> : Junction<T> { }

sealed class OtherLevel2<T> : Junction<T> { }