Interface in C#

Question

I am new to OOP and have some questions.

1. Why can't methods declared in an interface have modifiers(public,private etc).

2. In this code:

class Program
{
    static void Main(string[] args)
    {
        X ob = new Y();
        ob.add(4, 5);
        Z ob1 = new Y();
        ob1.mull(2, 3);
        Console.Read();
    }
}

public interface X
{
    void add(int x, int y);
}
public interface Z
{
    void mull(int x, int y);
}

class Y : X, Z
{
    void X.add(int x, int y)//here we are not decalring it as public ,why?
    {
        Console.WriteLine("sum of X and y is " + (x + y));
    }
    void Z.mull(int x, int y)
    {
        Console.WriteLine("product of X and Y is" + (x * y));
    }
}

Both methods don't require modifiers but when I don't use interface, like X.add() above, I need to make the implementation public. Why?

Answer 1

An interface is a contract. It says "I can do these things." What's the point of someone handing you an instance of IInterface wherein you can't use some of the methods in that contract because they've been marked not public?

This is the rationale for designing the language in this way. The specification for this is in §13.2 of the language specification:

All interface members implicitly have public access. It is a compile-time error for interface member declarations to include any modifiers. In particular, interfaces members cannot be declared with the modifiers abstract, public, protected, internal, private, virtual, override, or static.

As for your code, that is an example of explicit interface implementation. It is most useful for when a class or struct implements two interfaces each with a member having the same signature. For example, both IEnumerable and IEnumerable<T> define a method GetEnumerator accepting no parameters.

public interface IEnumerable {
    IEnumerator GetEnumerator();
}

public interface IEnumerable<T> : IEnumerable {
    IEnumerator<T> GetEnumerator();
}

Note that by the above definitions, any class that implements IEnumerable<T> must also implement IEnumerable. Keep in mind that the return type is not part of the signature and thus we have a conflict with IEnumerable.GetEnumerator and IEnumerable<T>.GetEnumerator. This is what explicit interface implementation is meant to solve:

class X<T> : IEnumerable<T> {
    List<T> _list = new List<T>();
    public IEnumerator<T> GetEnumerator() {
        return _list.GetEnumerator();
    }

    IEnumerator GetEnumerator() {
        return GetEnumerator(); // invokes IEnumerable<T>.GetEnumerator
    }
}

Members that are explicit interface implementations are only visible through an instance of the interface. Thus:

X<int> x = new X<int>();
var e1 = x.GetEnumerator(); // invokes IEnumerable<int>.GetEnumerator
                           // IEnumerable.GetEnumerator is not visible
IEnumerable y = x;
var e2 = y.GetEnumerator(); // invokes IEnumerable.GetEnumerator

Thus, in your code

X ob = new Y();
ob.add(1, 2); // X.add is visible through interface
Y y = new Y();
y.add(1, 2); // compile-time error, X.add is not visible

Both methods don't require modifiers but when I don't use interface, like X.add() above, I need to make the implementation public. Why?

Okay, it's not clear exactly what you're asking here. Access modifiers are not allowed for explicit interface implementations. This is 13.4:

It is a compile-time error for an explicit interface member implementation to include access modifiers, and it is a compile-time error to include the modifiers abstract, virtual, override, or static.

If a interface implementation is not marked as being an explicit interface implementation, then it must have the access modifier public. This is 13.4.4 (Interface mapping):

Interface mapping for a class or struct C locates an implementation for each member of each interface specified in the base class list of C. The implementation of a particular interface member I.M, where I is the interface in which the member M is declared, is determined by examining each class or struct S, starting with C and repeating for each successive base class of C, until a match is located

• If S contains a declaration of an explicit interface member implementation that matches I and M, then this member is the implementation of I.M

• Otherwise, if S contains a declaration of a non-static public member that matches M, then this member is the implementation of I.M.

A compile-time error occurs if implementations cannot be located for all members of all interfaces specified in the base class list of C.

So, in short, the compiler first looks for an explicit interface implementation. If it can not find one then it looks for a non-static, public member with the same signature as the method M being implemented. If it can not find one a compile-time error occurs. So the rules are this. To implement an interface member I.M:

1. If you implement I.M explicitly then the syntax is

   return-type I.M(parameter-list)

2. Otherwise, the syntax is

   public return-type M(parameter-list)

Thus, with

interface IAdd {
    int Add(int x, int y)
}

We can implement explicitly:

class Explicit : IAdd {
    int IAdd.Add(int x, int y) { return x + y; }
}

or not:

class NotExplicit : IAdd {
    public int Add(int x, int y) { return x + y; }
}

The difference is then that Explicit.Add is not visible unless instances of Explicit are typed as IAdd:

IAdd explicitInterface = new Explicit();
explicitInterface.Add(2, 2);
Explicit explicit = new Explicit();
explicit.Add(2, 2); // compile-time error

whereas

IAdd notExplicitInterface = new NotExplicit();
notExplicitInterface.Add(2, 2);
NotExplicit notExplicit = new NotExplicit();
notExplicit.Add(2, 2); // okay, NOT a compile-time error as above

Does that help?

Answer 2

Interface is like a contact. When a class implements certain interface you are guaranteed that the interface members exist in the class to. If it was possible to change visibility then it would not work.

You might want to have a look at these questions:

How will I know when to create an interface?
Why can’t I have protected interface members?

Answer 3

Because interface members are automatically public. You're defining a contract through an interface, and it wouldn't make any sense for the members not to be public, as you must implement them in your implementing class.