5

The responsibility of the visibility of a method is relegated to the class that implements the interface.

public interface IMyInterface
{
  bool GetMyInfo(string request);
}

In C# set access modifier public, private or protected before the method GetMyInfo() generates the following error: The modifier 'private' is not valid for this item.

Is there a reason you can not define the access modifier on a method or in an interface?

(Question already asked in french here)

Bastien Vandamme
  • 17,659
  • 30
  • 118
  • 200
  • possible duplicate of [Non Public Members for C# Interfaces](http://stackoverflow.com/questions/17576/non-public-members-for-c-sharp-interfaces) – nawfal May 11 '13 at 10:56

5 Answers5

14

The interface defines a contract between an object and clients that call its members. A private method cannot be accessed by any other objects so it doesn't make sense to add it to the interface. All members of an interface are considered public for this reason.

GraemeF
  • 11,327
  • 5
  • 52
  • 76
10

You can actually make the method private in the implementing class, if you make an explicit interface implementation:

public interface IMyInterface
{
    bool GetMyInfo(string request);
}

public class MyClass : IMyInterface
{
    public void SomePublicMethod() { }

    bool IMyInterface.GetMyInfo(string request)
    {
        // implementation goes here
    }
}

This approach means that GetMyInfo will not be part of the public interface of MyClass. It can be accessed only by casting a MyClass instance to IMyInterface:

MyClass instance = new MyClass();

// this does not compile
bool result = instance.GetMyInfo("some request"); 

// this works well on the other hand
bool result = ((IMyInterface)instance).GetMyInfo("some request");

So, in the context of the interface, all its members will be public. They can be hidden from the public interface of an implementing class, but there is always the possibility to make a type cast to the instance and access the members that way.

Fredrik Mörk
  • 155,851
  • 29
  • 291
  • 343
  • 1
    +1 for that extra bit of info. However, I've never understood why, or in what circumstances, this behavior is desirable(???) – Yoopergeek Oct 30 '09 at 22:07
4

In terms of OO - encapsulation is all about data hiding. That means whatever goes on inside a class is up to the class implementation. Which means it would be useless to contractually enforce private members.

However, the reason one uses interfaces is because you want to ensure a class adheres to a specific contract and exposes several public members in a consistent way.

Wim
  • 11,998
  • 1
  • 34
  • 57
  • Indeed, what if, in real life, the physical interface to connect the cord to your monitor to your computer was arbitrarily missing some pins (because they were missing/hidden/private)? It just wouldn't work. That's why even virtual interfaces must be fully there and exposed. – John K Oct 30 '09 at 21:31
1

All of the methods of an interface must have the same access level - so that the caller may use all of them. However interfaces can also be internal (or as nested interface private).

If you need different access levels use a distinct interface.

chriseyre2000
  • 11
  • 2
0

A private definition in the interface would:

  1. provide no benefit to the user of the interface (it is private after all)
  2. constrain the implementing class to have to implement the method or property
  3. muddy the conceptual nature of the interface with implementational detail
  4. be like an abstract class with a private method (which is not allowed)
Matt Breckon
  • 3,374
  • 20
  • 26
  • A "private" modifier may not be useful, but an "internal" access modifier would be. There are situations where one wants to allow outside code to pass around references to an abstract class, but not use all its features or create objects which are substitutable for it. There are situations which the graph of what types of objects should be substitutable for each other isn't a tree, and thus can only be modeled with interfaces, rather than just inheritance. When the two situations overlap, internal interface methods would be useful. – supercat Dec 09 '11 at 22:42