泛型类中静态字段的合适解决方法？

Question

Given that generic types create separate instances of static fields per-type combination, is this a valid pattern to use if I want to have a static field across all types?

public class BaseClass
{
    public static int P = 0;
}

public class ChildClass<T> : BaseClass
{
    public static int Q = 0;

    public void Inc()
    {
        // ChildClass<int> will have a different "Q" than ChildClass<double> 
        Interlocked.Increment(ref Q); 
        // all types of ChildClass will increment the same P
        Interlocked.Increment(ref P); 
    }
}

Is there anything unsafe about this approach? My toy example works, but I just wanted to make sure there are no horrible side effects, threading consequences, etc :)

Answer 1

You can use Interlocked.Increment for more thread-safe code.

public void Inc()
{
    Interlocked.Increment(ref Q); // ChildClass<int> will have a different "Q" than ChildClass<double> 
    Interlocked.Increment(ref P); // all types of ChildClass will increment the same P
}

or plain old lock

public class BaseClass
{
    protected static int P = 0;
    protected static object pLock = new object();
}

public class ChildClass<T> : BaseClass
{
    private static int Q = 0;
    private static object qLock = new object();

    public void Inc()
    {
        lock(qLock)
        {
            qLock++;
        }

        lock(pLock)
        {
            qLock++;
        }
    }
}

Note that for every T there will be a different ChildClass<T>.Q , but there shall only ever be one BaseClass.P . That means you'd have to use separate lock objects for dealing with Q and P (technically anything you use to lock P can also be used to lock all Q 's but that's probably not what you want to do).

Answer 2

Your pattern is valid and has no issues. There is no such thing as static inheritance , but you can access the static members of any type just like you normally would (provided they are visible to your derived class, eg not private ):

BaseClass.P = 10;
ChildClass<string>.Q = 20;

The C# specification states that single reads or writes to 32-bit integers (ie int ) are atomic , which means they can complete within a single instruction and never will a half-written variable be visible to another thread.

12.5 Atomicity of variable references

Reads and writes of the following data types shall be atomic: bool, char, byte, sbyte, short, ushort, uint, int, float, and reference types. In addition, reads and writes of enum types with an underlying type in the previous list shall also be atomic. Reads and writes of other types, including long, ulong, double, and decimal, as well as user-defined types, need not be atomic.

Of course, reading and writing is not guaranteed to be atomic. For example, incrementing a variable's value requires it to be read then written, and that's where the Interlocked methods come into play.

By the way, you are probably aware that you'll get only one P static variable, but as many Q static variables as there are different generic instances of your type ChildClass<T> .