静态方法无法实现接口方法，为什么？

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();

    }
}

编译器错误：XXX.Foo（）无法实现接口成员，因为它是静态的。

为什么静态方法不能实现接口方法？

Answer 1

请参阅JoelOnSoftware的这个帖子，描述其背后的原因。

基本上，接口是使用者和提供者之间的契约，静态方法属于该类，而不是类的每个实例。

关于SO的早期问题也涉及完全相同的问题： 为什么C＃不允许静态方法实现接口？

Answer 2

接口定义对象必须响应的行为。 由于Foo是静态方法，因此对象不响应它。 换句话说，你不能写......

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

换句话说，myXXX并不完全满足接口的要求。

Answer 3

如果我们将接口视为对象可以执行接口中列出的方法的承诺，那么静态实现的想法就会成为问题。 如果实现是静态的，那么就不能编写新的ImplementingObject（）。ImplementedMthod。 该对象无法执行该方法，该类可以。

Answer 4

您使用接口来避免在实例化期间使用具体类。 您无法通过实例化类访问静态方法，因此不允许使用静态方法实现接口方法。

Answer 5

好吧，我相信在泛型类型参数的情况下应该允许它。 它可能简化了合同单身人士课程。 这是一个例子：

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);
  } 

}

唯一一次类型引用隐含在SqlProvider.read（）中，而write（）和T在调用时是良好的标识。 如果没有静态的接口实现，我就不得不这样写。

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);
  }

差别很小但不太优雅。

Answer 6

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