Question

Why was C# designed this way?

As I understand it, an interface only describes behaviour, and serves the purpose of describing a contractual obligation for classes implementing the interface that certain behaviour is implemented.

If classes wish to implement that behavour in a shared method, why shouldn’t they?

Here is an example of what I have in mind:

// These items will be displayed in a list on the screen. public interface IListItem {   string ScreenName();   ... }  public class Animal: IListItem {     // All animals will be called 'Animal'.     public static string ScreenName() {         return 'Animal';     } .... }  public class Person: IListItem {      private string name;      // All persons will be called by their individual names.     public string ScreenName() {         return name;     }      ....   } 

Answer 1

Assuming you are asking why you can’t do this:

public interface IFoo {     void Bar(); }  public class Foo: IFoo {     public static void Bar() {} } 

This doesn’t make sense to me, semantically. Methods specified on an interface should be there to specify the contract for interacting with an object. Static methods do not allow you to interact with an object – if you find yourself in the position where your implementation could be made static, you may need to ask yourself if that method really belongs in the interface.

---

To implement your example, I would give Animal a const property, which would still allow it to be accessed from a static context, and return that value in the implementation.

public class Animal: IListItem {     /* Can be tough to come up with a different, yet meaningful name!      * A different casing convention, like Java has, would help here.      */     public const string AnimalScreenName = 'Animal';     public string ScreenName(){ return AnimalScreenName; } } 

For a more complicated situation, you could always declare another static method and delegate to that. In trying come up with an example, I couldn’t think of any reason you would do something non-trivial in both a static and instance context, so I’ll spare you a FooBar blob, and take it as an indication that it might not be a good idea.