用静态方法确定引用类型

Question

I think this may not be possible but if it is SO would know.

I have a abstract class that statically maintains instances of it's subclasses. I would like to implement a static getInstance() method in my base class that will get instance of the whichever class is referenced. So I need a way to tell which class was referenced in the static call.

I think the code will make this more clear:

abstract class Base
{
    private static List<Base> allInstances;
    public static List<Base> AllInstances
    {
        get {
            if(allInstances==null)
            {
                // Implementation not relevant and not included to avoid clutter
            }
            return allInstances;
        }
    }
    public static Base getInstance()
    {
        Type callingType = // This is what I am trying to fill in
        if(callingType == typeof(Base))
            throw new InvalidOperationException("Cannot get instance of Base class");
        return AllInstances.Find(i => i.GetType() == callingType);
    }
}


class A:Base { }
class B:Base { }

So if I called A.getInstance() my callingType variable would be typeof(A) . My primary goal is avoid having Find calls in my code to make it cleaner and more readable but I am also just curious if this is possible.

Answer 1

C# does not support virtual static methods.

One workaround would be to use a generic method for GetInstance() . Instead of calling A.GetInstance() , callers would call Base.GetInstance<A>() . The effect would be the same, however:

abstract class Base
{
...
  public static T getInstance<T>() where T : Base
  {
    Type callingType = typeof(T);
    // no need to check type; T will always be a type of or derived from Base
    return AllInstances.Find(i => i.GetType() == callingType) as T;
  }
}

While it would involve some boilerplate, you could then (if you choose) write convenience methods at the derived class level to obtain the same effect:

class A:Base 
{
    public static A getInstance() {return Base.getInstance<A>();}
}
class B:Base
{
    public static B getInstance() {return Base.getInstance<B>();}
}

Answer 2

Static methods are not inherited. They are scoped to their class. The way you have it written there is no "getInstance" method on A or B...only on Base. So what you're trying to do isn't quite possible via your approach.

However, you can go with a generic method:

public static T GetInstance<T>() where T : Base {
    return (T)AllInstances.Find(i => i.GetType() == typeof(T));
}

Then you can just request instances of the types like this

var a = Base.GetInstance<A>();
var b = Base.GetInstance<B>();

Just as easy as

var a = A.getInstance();
var b = B.getInstance();

and because type T is limited to types that inherit base (via T : Base), you don't have to worry about other types of classes because this won't even compile:

var x = Base.GetInstance<SomeOtherRandomClass>();

Answer 3

Expanding on my comments above, you can't really do what you are asking without putting code in all the derived classes. Part of the reason is that while you are able to access A.getInstance() and B.getInstance() they are both compiled down to the call Base.getInstance() . See the IL of simple method such as:

public static void CallGetInstance()
{
    var a = A.getInstance();
    var b = B.getInstance();
    Console.WriteLine(a == b);
}

is compiled to:

.method private hidebysig static
    void CallGetInstance () cil managed
{
    // Method begins at RVA 0x2054
    // Code size 24 (0x18)
    .maxstack 2
    .locals init (
        [0] class TestIL.Base a,
        [1] class TestIL.Base b
    )

    IL_0000: nop
    IL_0001: call class TestIL.Base TestIL.Base::getInstance()
    IL_0006: stloc.0
    IL_0007: call class TestIL.Base TestIL.Base::getInstance()
    IL_000c: stloc.1
    IL_000d: ldloc.0
    IL_000e: ldloc.1
    IL_000f: ceq
    IL_0011: call void [mscorlib]System.Console::WriteLine(bool)
    IL_0016: nop
    IL_0017: ret
} // end of method Program::CallGetInstance

Note that there is no mention of A.getInstance or B.getInstance . In fact, they do not exist in the IL. Tricks with StackFrame and such won't help because there is no method in the IL for A.getInstance() and B.getInstance() .

One workaround has been proposed by the other answers using a generic method that each derived class calls. This is about as simple as it is going to get.