c# static in abstract superclass will be shared among subclasses?

Question

i'm writing some ashx handlers which are wired to a mock service, and i want them to share the mock service instance. The simplest approach i though was creating a static instance

public class AbstractHandler
    {
        static IService _impl;
        public static IService Impl
        {
            get
            {
                if (_impl == null)
                {
                    _impl = new MockService();
                }
                return _impl;
            }
        }
    }

However, i'm wondering if this is going to work at all; will different handlers that inherit from this class will have their own static _impl reference or they will be shared?

Answer 1

A static field exists once, except in the case of a generic type, in which case it exists once for each used combination of generic parameters.

Even if the class is a base class, possibly abstract, the same rules apply. Note that if the class in which the field is declared is not generic, the field will exist once, even if descendants are generic. The rule about "once per combination ..." only comes into play if the class that declares the static field is generic.

So, if your question instead had been:

How can I make the static field be per descendant and not just once

Then the answer would've been that you should make your base class generic, and pass the descendant type as the generic parameter.

Example LINQPad script to demonstrate the "once per generic parameter combination":

void Main()
{
    var i = new Test<int>();
    var s = new Test<string>();

    Test<bool>.UsageCount.Dump();
    Test<int>.UsageCount.Dump();
    Test<string>.UsageCount.Dump();
}

public class Test<T>
{
    public static int UsageCount;

    public Test()
    {
        UsageCount++;
    }
}

Output:

0
1
1

Example to demonstrate with base class:

void Main()
{
    var i = new Test1();
    var s = new Test2();

    Test1.UsageCount.Dump();
    Test2.UsageCount.Dump();
    Test3.UsageCount.Dump();
}

public abstract class Base<T>
{
    public static int UsageCount;

    protected Base()
    {
        UsageCount++;
    }
}

public class Test1 : Base<Test1>
{
}

public class Test2 : Base<Test2>
{
}

public class Test3 : Base<Test3>
{
}

Output:

1
1
0