static method cannot implement interface method, why?

Question

interface IXXX
{
    void Foo();
}

class XXX : IXXX
{
    public static void Foo()
    {
        Console.WriteLine("From XXX");
    }
}


class Program 
{
    static void Main(string[] args)
    {
        XXX.Foo();

    }
}

Compiler error: XXX.Foo() cannot implement an interface member because it is static.

Why can't a static method implement an interface method?

Answer 1

See this thread from JoelOnSoftware describing the reasons behind this.

Basically the interface is the contract between the consumer and the provider, and a static method belongs to the class, and not each instance of the class as such.

An earlier question on SO also deal with the exact same question: Why Doesn't C# Allow Static Methods to Implement an Interface?

Answer 2

An interface defines the behaviour that an object must respond to. As Foo is a static method, the object doesn't respond to it. In other words, you couldn't write...

XXX myXXX = new XXX();
myXXX.Foo();

In other words, myXXX doesn't fully satisfy the requirements of the interface.

Answer 3

IF we look at interfaces as a promise that an object can perform the methods listed in the interface, then ths idea of static implementation becomes problematic. If the implemetion is static, then you can't write new ImplementingObject().ImplementedMthod. The object can't perform the method, the class can.

Answer 4

You use interface to avoid using concrete class during instantiation. You can't access static method through instantiated class, so implementing interface methods with static methods is not allowed.

Answer 5

Well, I believe it should allowed in case of generic type parameter. It probably simplified contractual singleton class. Here is an example:

public interface IEntity {
   // some constrains...
  DataRow ObjToRow(object obj);
  object RowToObj(DataRow dr);
}

//T would be any class inherites from IEntity with default contructor signature.
public interface IMyContract {
  T read<T>() where T : IEntity;  
  void write<T>(T object) where T : IEntity;
}

//everything in the class is static
public static class SqlProvider : IMyContract {

  public static T read<T>() where T: IEntity {
    DataRow dr = [reading from database]
    return T.RowToObj(dr);
  }

  //compile error here....
  public static void write<T>(T obj) where T : IEntity {
    DataRow dr = T.ObjToRow(obj);

   [ ... commit data row dr to database ... ]

  }
}

public static class MyAppleEntity : IEntity  {
  [... implement IEntity contract normally ... ]
}

public static class MyOrangeEntity : IEntity {
   [... implement IEntity contract normally ... ]
}

public class MyTest {
  void reading() {
     MyAppleEntity apple = SqlProvider.Read<MyAppleEntity>();
     MyOrangeEntity orange = SqlProvider.Read<MyOrangeEntity>();

     SqlProvider.write<MyAppleEntity>(apple); 
     SqlProvider.write<MyOrangeEntity>(orange);
  } 

}

The only time a type reference implicitly is in the SqlProvider.read() and write() and T is well identity at point of invoke. Without static implementation of interface I'm forced to write like this.

public class MyAppleEntity : IEntity  {
  [... implement IEntity contract normally ... ]
}

  .....

  public T read<T>() where T: IEntity, new() {
    DataRow dr = [reading from database]
    return new T().RowToObj(dr);
  }

Very little different but not quite as elegant.

Answer 6

因为接口成员是公共的和可覆盖的，并且静态方法不能被设计覆盖或抽象，所以接口在这里定义一个可访问的契约，必须通过它们的具体实现来实现（具有抽象实现和继承接口之间的许多步骤）和据我所知，没有办法创建一个抽象的静态方法。