C＃将静态类放入字典中

Question

I was unclear in an earlier question I ask so I will try to be more explicit.

Is there a way to put a static class inside of a dictionary so that its functions can be called? If this is not possible, what is the best alternative that doesn't involve using instances that you can suggest?

Here is how I would like to use it:

static class MyStatic : IInterface
{
    static void Do(){}
}

static class MyStatic2 : IInterface
{
    static void Do(){}
}

class StaticMap
{
    static Dictionary<Type,IInterface.class> dictionary = new Dictionary<Type,IInterface.class>
    {
        {Type.1, MyStatic}
        {Type.2, MyStatic2}
    };
}

// Client Code

class ClientCode
{
    void Start()
    {
        StaticMap.dictionary[Type.1].Do();
    }
}

Answer 1

There are some fundamental reasons why you can't do that directly:

• Static method calls are bound at compile-time
• Static calls are not inherited - they are tied to the class that defines them
• There is no implicit base type (and therefore no polymorphism) between static methods, even if the name, inputs, and outputs are all the same

Since your signature is the same for every static method, you could store a Action in the dictionary instead:

static Dictionary<Type,Action> dictionary = new Dictionary<Type,Action>
{
    {Type.1, MyStatic.Do}
    {Type.2, MyStatic2.Do}
};

then you can call the Action directly:

void Start()
{
    StaticMap.dictionary[Type.1]();
}

It's slightly repetetive because you have to specify the method name in the dictionary as well, but it's type safe.

Answer 2

A key question is whether you want to call a single method on each type or whether you need to call multiple methods belonging to each type.

If it's just a single method, then what D Stanley suggested is the answer. If you store a number of Action s, each representing a method with the same signature on a different static class, then you're accomplishing what you said.

However that raises a question - why the constraint that each method must belong to a separate static class? This approach would work just as well if some or all of the methods belonged to the same class.

If you need to call more than one method from each class then an Action no longer works. You'd have to store collections of Action , which a) means class instances, and b) is a lot more complicated than just using interfaces and class instances.

One way to manage instances is by using a dependency injection container to create class instances for you. Using that approach, you can create non-static classes without having to go through the hassle of explicitly making them singletons. But you can tell the container to only produce one of each and reuse it. For example, using Castle Windsor:

container.Register(Component.For<ISomeInterface,SomeClass>));

Now every time the container is asked to provide an instance of ISomeInterface it will always provide the same instance of SomeClass .

Because the dependency you're looking for varies by type ( Dictionary<Type, Something> ) it sounds like what you're looking for might be related to generics. But it would be necessary to take a step back from the smaller problem and understand a slightly larger picture of what you're trying to accomplish.

Answer 3

Instead of having the entire class as static, create a Singleton instance.

public class Foo
{
   public static Foo _Foo;
   public Foo()
   {
      _Foo = this;
   }
}

Then you may add it to your list, and also inherit from Interfaces, etc.