Is a static member variable common for all C# generic instantiations?

Question

In C# I have a generic class:

public class MyGeneric<ParameterClass> where ParameterClass: MyGenericParameterClass, new() {
    public static int Variable;
}

Now in C++ if I instantiated a templated class with different parameters each complete class would get it's own Variable, so I just can't say

MyGeneric.Variable = 1; // invalid in C++

in C++, but seems like I can do so in C#.

I'd like to clarify...

If I have a generic with a static member variable is that variable shared among all generic instantiations?

Gemini

Answer 1

Section 25.1.4 of the ECMA C# Language specification

A static variable in a generic class declaration is shared amongst all instances of the same closed constructed type (§26.5.2), but is not shared amongst instances of different closed constructed types. These rules apply regardless of whether the type of the static variable involves any type parameters or not.

You may see this blog post: Static fields in generic classes by Gus Perez

You can't do that in C# as well.

MyGeneric.Variable = 1;

Consider the following example from ECMA Language Specification.

class C<V>
{
    static int count = 0;
    public C()
    {
        count++;
    }
    public static int Count
    {
        get { return count; }
    }
}
class Application
{
    static void Main()
    {
        C<int> x1 = new C<int>();
        Console.WriteLine(C<int>.Count);  // Prints 1 
        C<double> x2 = new C<double>();
        Console.WriteLine(C<double>.Count); // Prints 1 
        Console.WriteLine(C<int>.Count);  // Prints 1 
        C<int> x3 = new C<int>();
        Console.WriteLine(C<int>.Count);  // Prints 2 
    }
}

Drink

Answer 2

MyGeneric<MyClass>.Variable
MyGeneric<MyOther>.Variable

These two are different static variables treated like separate classes.

Molech

Answer 3

No, it is not. Generic types can be "open" or "closed." An open type is one like List<T> where the type parameter isn't defined; List<int> is a closed type.

Essentially, the open type isn't treated as a proper "Type" by the runtime - only the closed versions are true types. So, MyGeneric<int> and MyGeneric<string> are two entirely different types, and thus have their own instances of the static variable.

This is made more obvious by the fact that you can't call your static member in the way you suggest: MyGeneric.Variable will not compile in C#.

This console application code illustrates it quite simply:

class Program
{
    static void Main(string[] args)
    {
        Test<int>.i = 2;
        Test<string>.i = 8;

        Console.WriteLine(Test<int>.i);   // would write "8" if the fields were shared
        Console.WriteLine(Test<string>.i);
        // Console.WriteLine(Test.i); // does not compile
        // Console.WriteLine(Test<>.i); // does not compile
    }
}

class Test<T>
{
    public static int i;
}

Unhesitating

Answer 4

No, it is not shared.

Each MyGeneric<T> class will resolve to a different runtime type, for each possibility of T.

Please check that there is no non-generic MyGeneric class with the Variable static member.

Xymenes

Answer 5

As stated, the answer to your question is no. However, what you can do is use a parent class to your generic class, and have your static variable in there. Any method you need to call could be abstracted into that parent class.

abstract class MyBase
{
    protected static MyBase selected;

    public abstract void Deselect();
}

class MyGeneric<T> : MyBase
{
    public void Select()
    {
        if (selected != null)
        {
            if (selected != this)
            {
                selected.Deselect();
            }
        }
        selected = this;
        //...
    }

    public override void Deselect()
    {
        //...
    }
}

Surgeon