静态和实例方法同名？

Question

I have a class with both a static and a non-static interface in C#. Is it possible to have a static and a non-static method in a class with the same name and signature?

I get a compiler error when I try to do this, but for some reason I thought there was a way to do this. Am I wrong or is there no way to have both static and non-static methods in the same class?

If this is not possible, is there a good way to implement something like this that can be applied generically to any situation?

EDIT
From the responses I've received, it's clear that there is no way to do this. I'm going with a different naming system to work around this problem.

Answer 1

No you can't. The reason for the limitation is that static methods can also be called from non-static contexts without needing to prepend the class name (so MyStaticMethod() instead of MyClass.MyStaticMethod()). The compiler can't tell which you're looking for if you have both.

You can have static and non-static methods with the same name, but different parameters following the same rules as method overloading, they just can't have exactly the same signature.

Answer 2

Actually, there kind of is a way to accomplish this by explicitly implementing an interface. It is not a perfect solution but it can work in some cases.

interface IFoo
{
    void Bar();
}

class Foo : IFoo
{
    static void Bar()
    {
    }

    void IFoo.Bar()
    {
        Bar();
    }
}

I sometimes run into this situation when I make wrapper classes for P/Invoke calls.

Answer 3

You can call static methods from instance methods without having to specify the type name:

class Foo
{
    static void Bar()
    {
    }

    void Fizz()
    {
        Bar();
    }
}

... so it makes sense that you wouldn't be allowed to have a static method and an instance method with the same signature.

What are you trying to accomplish? It's hard to suggest a workaround without knowing specifics. I'd just rename one of the methods.

Answer 4

C# is not well designed when it comes to this...

While it is true that you could want the global or non-global, it should pick one by default, and if you want the other then you simply qualify it more.

class Logger {
   public static Logger instance;

   public static void Log(string message) {
       instance.Log(message); // currently the compiler thinks this is ambiguous, but really its not at all.  Clearly we want the non-static method
   }

   public void Log(string message) {

   }

   public void DoStuff() {
      Log("doing instance stuff"); // this could be ambiguous, but in my opinion it should default to a call to this.Log()
      Logger.Log("doing global stuff"); // if you want the global qualify it explicitly
   }
}

Answer 5

You can have static and instance method with the same name, as long as their declaration differs in the number or type of parameters. It's the same rule on how you can have two instance methods with the same name in a class.

Though technically, in the case of static vs. instance method, they already differ by the presence of the implicit this parameter in the instance method, that difference is not enough for the compiler to determine which of the two you want to call.

Update : I made a mistake. Return values are not enough to have different signature.

Answer 6

OK. The root of this problem is that C# should not let you call a static method from an instance method without specifying the type name.

Other full OO languages (like Smalltalk) don't allow this and also its just confusion to people who understand objects. The seperation between instance side and class (or static) side is very important and having a language that promotes confusion in those details is........not a good idea....but typical of the type stuff we expect from MS.

Adrian