Introduction
Interfaces in C # provide a way to achieve runtime polymorphism. Using interfaces we can invoke functions from different classes through the same Interface reference, whereas using virtual functions we can invoke functions from different classes in the same inheritance hierarchy through the same reference. Before things start getting difficult let me start using simple and short examples to explain the concept of interfaces. Here's a short example that shows you what an interface looks like.P1.cs
class Demo
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
}
}
interface abc
{
}
Output
Hello Interfaces
The above program compiles and runs successfully to produce the desired output. The above program consists of a class Demo and within it an entry point function Main() that prints Hello Interfaces. The above program also defines an interface abc. Interface abc is empty at this point of time. Let's add some elements to this interface.
P2.cs
class Demo
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
}
}
interface abc
{
int x;
}
Output
P2.cs(11,3): error CS0525: Interfaces cannot contain fields
Error! Interfaces in C# cannot contain fields i.e variables. The above program declared an integer variable x in the interface abc. And that's what hit the C# compiler badly.
P3.cs
class Demo
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
}
}
interface abc
{
void xyz()
{
System.Console.WriteLine("In xyz");
}
}
Output
P3.cs(11,8): error CS0531: 'abc.xyz()': interface members cannot have a
definition
This time over we included a function xyz() inside the
interface found that this too hurt the C# compiler. It told us loudly
that interface members cannot have a defination. Does this mean that if
we just have a function declaration inside the interface abc that is fine with the C# compiler? Let's find it out.
P4.cs
class Demo
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
}
}
interface abc
{
void xyz();
}
Output
Hello Interfaces
The above program compiles and runs successfully to produce the
desired output. Finally we made the compiler happy. Interfaces in C# can
only contain function declarations. Now let us see interfaces in
action.
Interfaces are contracts that a class implements in its own way. This means an interface will contain function prototypes and a class that marries this interface will have to take the responsibility of defining the functions whose prototypes are declared by the marrying interface.
So its time to perform the marriage between our groom class
Demo and the bride interface abc.
P4.cs
class Demo : abc
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
}
}
interface abc
{
void xyz();
}
Output
P4.cs(1,7): error CS0535: 'Demo' does not implement interface member
'abc.xyz()'
P4.cs(11,8): (Location of symbol related to previous error)
Well, in the above program class Demo did marry the interface abc through the line class demo : abc but as usual there's a small misunderstanding between the newlyweds. Class Demo needs to take the responsibility of defining the functions whose prototypes are declared by the marrying interface abc. Since class Demo in the above program has not been implemented i.e. defined the function xyz whose prototype is declared by the marrying interface abc we get an error in the above program. To fix this issue, the class Demo has to take the responsiility of defining the function xyz whose prototype is declared by the marrying interface abc. And that is what you get to see in the following program.
P5.cs
class Demo : abc
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
}
void xyz()
{
System.Console.WriteLine("In xyz");
}
}
interface abc
{
void xyz();
}
Output
a.cs(1,7): error CS0536: 'Demo' does not implement interface member
'abc.xyz()'.'Demo.xyz()' is either static, not public,
or has the wrong return type.
a.cs(16,8): (Location of symbol related to previous error)
a.cs(7,8): (Location of symbol related to previous error)
Error again! It's not enough for the class Demo to implement the function xyz. It has to impress the bride interface abc by declaring its implementation of xyz as public. And that's what is done by the following program.
P6.cs
class Demo : abc
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
xyz();
}
public void xyz()
{
System.Console.WriteLine("In xyz");
}
}
interface abc
{
void xyz();
}
Output
Hello Interfaces
In xyz
Bingo! The above program compiles and runs successfully to produce
the desired output. As mentioned earlier using interfaces we can invoke
functions from different classes using the same interface reference. For
this, we need to have different classes to implement the same
interface. In the above program our class Demo is implementing the interface abc. Let's have another class Sample that implements the interface abc.
P7.cs
class Demo : abc
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
refDemo.xyz();
Sample refSample = new Sample();
refSample.xyz();
}
public void xyz()
{
System.Console.WriteLine("In Demo :: xyz");
}
}
interface abc
{
void xyz();
}
class Sample : abc
{
public void xyz()
{
System.Console.WriteLine("In Sample :: xyz");
}
}
Output
In Demo :: xyz
In Sample :: xyz
The above program compiles and runs successfully to produce the desired output. refDemo is a reference to the object of class Demo. refSample is a reference to the object of class Sample. Both the classes implement the interface abc and hence define their own implementation of the function xyz(). From within the entry point function Main() xyz() of the respective classes Demo and Sample are invoked through references refDemo and refSample.
Now that we have two different classes implementing the same interface its time to show you how to invoke functions from different classes using the same interface reference.
P8.cs
class Demo : abc
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
abc refabc = new Demo();
refabc.xyz();
abc refabc = new Sample();
refabc.xyz();
}
public void xyz()
{
System.Console.WriteLine("In Demo :: xyz");
}
}
interface abc
{
void xyz();
}
class Sample : abc
{
public void xyz()
{
System.Console.WriteLine("In Sample :: xyz");
}
}
Output
In Demo :: xyz
In Sample :: xyz
The above program compiles and runs successfully to produce the desired output. Inside Main() we have an interface reference refabc of type interface abc. Reference of object of class Demo is stored in refabc and xyz() of class Demo is invoked using refabc. Next, the reference of object of class Sample is stored in refabc and xyz() of class Sample is invoked using refabc. Thus, we were able to invoke xyz() that belongs to different classes Demo and Sample via a common interface reference refabc.
The following program uses a for loop to invoke the functions of different classes
Demo and Sample that implement the same interface "interface abc" using a single interface reference refabc whose type matches the interface "interface abc" which the classes impliment.
P9.cs
class Demo : abc
{
public static void Main()
{
abc [] refabc = {new Demo(), new Sample()} ;
for (int i = 0; i<= 1; i++)
refabc[i].xyz();
}
public void xyz()
{
System.Console.WriteLine("In Demo :: xyz");
}
}
interface abc
{
void xyz();
}
class Sample : abc
{
public void xyz()
{
System.Console.WriteLine("In Sample :: xyz");
}
}
Output
In Demo :: xyz
In Sample :: xyz
The above program compiles and runs successfully to produce the desired output. refabc is an array of type interface abc. It stores the references to objects of classes Demo and Sample. In the for loop, using the array refabc, we are invoking the function xyz() of class Demo and Sample.
A class can impliment as many interfaces as it wants. Take the following program.
P10.cs
class Demo : abc, def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
abc refabc = new Demo();
refabc.xyz();
}
public void xyz()
{
System.Console.WriteLine("In xyz");
}
public void pqr()
{
System.Console.WriteLine("In xyz");
}
}
interface abc
{
void xyz();
}
interface def
{
void pqr();
}
Output
Hello Interfaces
In xyz
The above program compiles and runs successfully to produce a desired output. Class Demo implements interface abc and thereby function xyz(). Class Demo also impliments interface def and thereby function pqr(). ref abc which is a variable of type Interface abc, refers to object of class Demo. Next xyz() of Demo is invoked via refabc as refabc is a variable of type Interface abc which contains the prototype for function xyz().
P11.cs
class Demo : abc, def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
abc refabc = new Demo();
refabc.xyz();
refabc.pqr();
}
public void xyz()
{
System.Console.WriteLine("In xyz");
}
public void pqr()
{
System.Console.WriteLine("In xyz");
}
}
interface abc
{
void xyz();
}
interface def
{
void pqr();
}
Output
P11.cs(9,5): error CS0117: 'abc' does not contain a definition for 'pqr'
Error! An attempt to invoke pqr() of Demo via refabc fails as refabc is a variable of type Interface abc which contains the prototype for function xyz() and NOT pqr(). One can invoke pqr() of Demo via a reference variable of type Interface def as the interface def contains the prototype for function pqr(). And that's what is done by the following program.
P12.cs
class Demo : abc, def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
abc refabc = refDemo;
refabc.xyz();
def refdef = refDemo;
refdef.pqr();
}
public void xyz()
{
System.Console.WriteLine("In xyz");
}
public void pqr()
{
System.Console.WriteLine("In pqr");
}
}
interface abc
{
void xyz();
}
interface def
{
void pqr();
}
Output
Hello Interfaces
In xyz
In pqr
The above program compiles and runs successfully to produce a desired output. Class Demo impliments the interfaces abc and def. An object of class Demo is created and its reference is stored in refDemo. refabc which is a variable of type Interface abc, refers to the object of class Demo. Next xyz() of Demo is invoked via refabc as refabc is a variable of type Interface abc which contains the prototype for function xyz(). Similarly, refdef which is a variable of type Interface def, refers to object of class Demo. Next pqr() of Demo is invoked via refdef as refdef is a variable of type Interface def which contains the prototype for function pqr().
P13.cs
class Demo : abc, def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
abc refabc = refDemo;
refabc.xyz();
def refdef = refDemo;
refdef.xyz();
}
public void xyz()
{
System.Console.WriteLine("In xyz");
}
}
interface abc
{
void xyz();
}
interface def
{
void xyz();
}
Output
Hello Interfaces
In xyz
In xyz
The above program compiles and runs successfully to produce a desired output. Both the interfaces abc and def declare the prototypes for function xyz(). Class Demo implements interfaces abc as well as def and defines the function xyz() as well. Thus we can invoke the function xyz() through either of the interface reference variables (refabc or refdef) after storing the reference to the object of class Demo in refabc or refdef. This poses a question, how can we have an implementation of xyz that is specific to interface abc and implementation of xyz that is specific to def inside class Demo? Well, for this we need to use the fully qualified names as in the following program.
P14.cs
class Demo : abc, def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
abc refabc = refDemo;
refabc.xyz();
def refdef = refDemo;
refdef.xyz();
}
public void abc.xyz()
{
System.Console.WriteLine("In abc.xyz");
}
public void def.xyz()
{
System.Console.WriteLine("In def.xyz");
}
}
interface abc
{
void xyz();
}
interface def
{
void xyz();
}
Output
a.cs(13,15): error CS0106: The modifier 'public' is not valid for this item
a.cs(18,15): error CS0106: The modifier 'public' is not valid for this item
Bummer! We used the fully qualified name and we got an error. That's
because when we use fully qualified names for functions whose prototypes
are a part of interfaces, the compiler doesn't need decorators like
public. So we decided to remove the access specifier public from the
above program.
P15.cs
class Demo : abc, def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
abc refabc = refDemo;
refabc.xyz();
def refdef = refDemo;
refdef.xyz();
}
void abc.xyz()
{
System.Console.WriteLine("In abc.xyz");
}
void def.xyz()
{
System.Console.WriteLine("In def.xyz");
}
}
interface abc
{
void xyz();
}
interface def
{
void xyz();
}
Output
Hello Interfaces
In abc.xyz
In def.xyz
The above program compiles and runs successfully to produce a desired
output. A fully qualified naming system allows us to define interfaces
having same function prototypes. In the above example, interface abc and def contain the same function prototypes for function xyz(). Class Demo impliments both the interfaces. Using fully qualified names, it defines implementation of xyz that is specific to interface abc and implementation of xyz that is specific to interface def.
P16.cs
class Demo : def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
def refdef = refDemo;
refdef.xyz();
refdef.pqr();
}
public void xyz()
{
System.Console.WriteLine("In xyz");
}
public void pqr()
{
System.Console.WriteLine("In pqr");
}
}
interface abc
{
void xyz();
}
interface def : abc
{
void pqr();
}
Output
Hello Interfaces
In xyz
In pqr
The above program compiles and runs successfully to produce a desired output. Interfaces support inheritance. Interface def inherits prototypes from interface abc. Class Demo implements the interface def. Interface variable refdef stores the reference to object of class Demo. Functions xyz() and pqr() of class Demo are invoked through interface reference variable refdef.
What do you think of the fully qualified names of
xyz() and pqr() would be after interface def inherits from interface abc.
P17.cs
class Demo : def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
def refdef = refDemo;
refdef.xyz();
refdef.pqr();
}
void def.xyz()
{
System.Console.WriteLine("In xyz");
}
void def.pqr()
{
System.Console.WriteLine("In pqr");
}
}
interface abc
{
void xyz();
}
interface def : abc
{
void pqr();
}
Output
P17.cs(12,8): error CS0539: 'def.xyz' in explicit interface declaration is
not a member of interface
P17.cs(29,11): (Location of symbol related to previous error)
P17.cs(1,7): error CS0535: 'Demo' does not implement interface member
'abc.xyz()'
P17.cs(26,8): (Location of symbol related to previous error)
Bummer! The prototype of function xyz is an original member of interface abc. Thus, even if interface def inherits from the interface abc, the fully qualified name of the function xyz() remains as abc.xyz and not def.xyz
as done in the above program. In fact, we got a compiler error. This
can be fixed by using the correct fully qualified name of function xyz() as shown in the following program.
P18.cs
class Demo : def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
def refdef = refDemo;
refdef.xyz();
refdef.pqr();
}
void abc.xyz()
{
System.Console.WriteLine("In xyz");
}
void def.pqr()
{
System.Console.WriteLine("In pqr");
}
}
interface abc
{
void xyz();
}
interface def : abc
{
void pqr();
}
Output
Hello Interfaces
In xyz
In pqr
The above program compiles and runs successfully to produce a desired
output. But there are some pitfalls when using the fully qualified
function names.
P19.cs
class Demo : def
{
public static void Main()
{
System.Console.WriteLine("Hello Interfaces");
Demo refDemo = new Demo();
refDemo.xyz();
refDemo.pqr();
}
void abc.xyz()
{
System.Console.WriteLine("In xyz");
}
void def.pqr()
{
System.Console.WriteLine("In pqr");
}
}
interface abc
{
void xyz();
}
interface def : abc
{
void pqr();
}
Output
P19.cs(7,5): error CS0117: 'Demo' does not contain a definition for 'xyz'
P19.cs(8,5): error CS0117: 'Demo' does not contain a definition for 'pqr'
The above program fails to clear the compilation hurdle. refDemo refers to an object of class Demo. We are invoking xyz() using refDemo(). For C#, xyz() and ddd.xyz() are two different things. It knows that abc.xyz() exists. It also knows that just xyz() is nowhere in the class. That's why we get an error which says Class Demo does not contain a definition of xyz(). For C#, abc.xyz() can be invoked by an interface reference of type abc only. Similarly, def.pqr() can be invoked by an interface reference of type def only.
