Why Doesn’t C# Allow Static Methods to Implement an Interface?

by

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.

More Related Contents:

  1. Why are private fields private to the type, not the instance?
  2. How Function overloading saves memory [closed]
  3. How to capture value OOPS & Generic [closed]
  4. Program * does not contain a static ‘Main’ method suitable for an entry point
  5. Implement a coin jar in C# [closed]
  6. What is the difference between a field and a property?
  7. Why not inherit from List?
  8. How to loop through all enum values in C#? [duplicate]
  9. What is the difference between an interface and a class, and why I should use an interface when I can implement the methods directly in the class?
  10. How can I call the ‘base implementation’ of an overridden virtual method? [duplicate]
  11. Static vs non-static class members
  12. Why C# doesn’t implement indexed properties?
  13. Why can’t we change access modifier while overriding methods in C#?
  14. How abstraction and encapsulation differ?
  15. How do I target attributes for a record class?
  16. Why can’t I declare C# methods virtual and static?
  17. When should I choose inheritance over an interface when designing C# class libraries? [closed]
  18. Multiple Aggregates / Repositories in one Transaction
  19. The difference between virtual, override, new and sealed override
  20. C# code for association, aggregation, composition
  21. Cast interface to its concrete implementation object or vice versa?
  22. Is there a much better way to create deep and shallow clones in C#?
  23. C# method call with parameter name and colon
  24. Reference type variable recycling – is a new reference variable created every loop in a loop if declared therein?
  25. Can you explain Liskov Substitution Principle with a good C# example? [closed]
  26. Factory pattern in C#: How to ensure an object instance can only be created by a factory class?
  27. What is the difference between static methods in a Non static class and static methods in a static class?
  28. Using generics with XmlSerializer
  29. Why do both the abstract class and interface exist in C#?
  30. VB.NET equivalent of C# property shorthand?

Leave a Comment