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)
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.
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.
A private definition in the interface would:
