Interfaces
Interfaces
In order to rectify the drawback of multiple inheritance,
creators of C# have introduced a new concept called Interfaces. Java programmers
may be well aware of this concept. All interfaces should have to be declared
with the keyword interface. You can
implement any number of interfaces in a single derived class. But you should
provide signatures to all method definitions of the corresponding interfaces. To
illustrate, Listing 1 shows how to declare interfaces and implement them in a
class:
Listing 1
using
System;
interface Interdemo
{
void Show();
}
class
Interimp:Interdemo
{
public void Show()
{
Console.WriteLine("Show() method Implemented");
}
public static void Main(string[] args)
{
Interimp inter = new Interimp();
inter.Show();
}
}
Combining
Interfaces
Two or more interfaces can be combined into a single
interface and implement in a class as shown in Listing 2:
Listing 2
You can easily determine whether a particular interface is
implemented in a class by using is and as operators. is
operator enables you to check whether one type or class is compatible with
another type or class and it returns a Boolean value. Listing 3 illustrates the
usage of is operator by revisiting
Listing 2.
Listing 3
using
System;
interface Interdemo
{
bool Show();
}
interface Interdemo1
{
bool Display();
}
class
Interimp:Interdemo
{
public bool Show()
{
Console.WriteLine("Show() method Implemented");
return true;
}
public static void Main(string[] args)
{
Interimp inter = new Interimp();
inter.Show();
if(inter is Interdemo1)
{
Interdemo1 id = (Interdemo1)inter;
bool ok = id.Display();
Console.WriteLine("Method Implemented");
}
else
{
Console.WriteLine("Method not implemented");
}
}
While the is operator
returns a boolean value as shown in the above listing, as
operator returns null if there is any incompatibility between types. Listing 4
examines the usage of this operator. Here we have revisited Listing 3. Notice
the change in code inside the Main () method.
Listing 4
using
System;
interface Interdemo
{
bool Show();
}
interface Interdemo1
{
bool Display();
}
class
Interimpas:Interdemo
{
public bool Show()
{
Console.WriteLine("Show() method Implemented");
return true;
}
public static void Main(string[] args)
{
Interimpas inter = new Interimpas();
inter.Show();
Interdemo1 id = inter as Interdemo1;
if(null!=id)
{
bool ok = id.Display();
Console.WriteLine("Method Implemented");
}
else
{
Console.WriteLine("Method not implemented");
}
}
Avoiding
Name Ambiguity
Suppose you are declaring same method definitions in two
different interfaces. The compiler will naturally show an error due to ambiguity
of the implemented method. Even if you use “is” keyword, compiler will still
show warnings. In order to avoid this, you have to follow syntax like as shown
below:
Listing 5
Void
<interface name>.<method name>
{
//Body
goes here
}
The listing given below illustrates the application of
above concept in detail:
Listing 6
using
System;
interface Interdemo
{
void Show();
}
interface Interdemo1
{
void Show();
}
class
Interclash:Interdemo,Interdemo1
{
void Interdemo.Show()
{
Console.WriteLine("Show() method Implemented");
}
void Interdemo1.Show()
{
Console.WriteLine("Display() method Implemented");
}
public static void Main(string[] args)
{
Interclash inter = new Interclash();
inter.Interdemo.Show();
inter.Interdemo1.Show();
}
About the Author