An Interface is a reference type and it contains only abstract members.
A D V E R T I S E M E N T
Interface's
members can be Events, Methods, Properties and Indexers. But the interface contains
only declaration for its members. Any implementation must be placed in class that
realizes them. The interface can't contain constants, data fields, constructors,
destructors and static members. All the member declarations inside interface are
implicitly public.
Defining an Interface:
Let us look at a simple example for c# interfaces. In this example interface declares
base functionality of node object.
interface INode
{
string Text
{
get;
set;
}
object Tag
{
get;
set;
}
int Height
{
get;
set;
}
int Width
{
get;
set;
}
float CalculateArea();
}
The above INode interface has declared a few abstract properties and function which
should be implemented by the derived classes.
Sample for Deriving a class using a C# .Net interface
public class Node : INode
{
public Node()
{}
public string Text
{
get
{
return m_text;
}
set
{
m_text = value;
}
}
private string m_text;
public object Tag
{
get
{
return m_tag;
}
set
{
m_tag = value;
}
}
private object m_tag = null;
public int Height
{
get
{
return m_height;
}
set
{
m_height = value;
}
}
private int m_height = 0;
public int Width
{
get
{
return m_width;
}
set
{
m_width = value;
}
}
private int m_width = 0;
public float CalculateArea()
{
if((m_width<0)||(m_height<0))
return 0;
return m_height*m_width;
}
}
Now the above code has created a c# class Node that inherits from INode c# interface
and implement all its members. A very important point to be remembered about c#
interfaces is, if some interface is inherited, the program must implement all its
declared members. Otherwise the c# compiler throws an error.
The above code was a simple example of c# interface usage. Now this has to be followed
with some advanced details of interface building in C# .Net. The previous example used
only names of methods or properties that have the same names as in interface. But there
is another alternative method for writing the implementation for the members in class.
It uses full method or property name .
Multiple Inheritance using C# interfaces:
Next feature that obviously needs to be explained is multiple inheritance using c#
interfaces. This can be done using child class that inherits from any number of c#
interfaces. The inheritance can also happen with a combination of a C# .Net class and
c# interfaces. Now let us see a small piece of code that demonstrate us multiple
inheritance using only interfaces as parent data types
class ClonableNode : INode,ICloneable
{
public object Clone()
{
return null;
}
// INode members
}
The above example created a class ClonableNode. It implements all the functionality of
INode interface in the same way as it was done in Node class. Also it realizes Clone
method only one item of IClonable interface of .NET library.
is Operator for C# .Net interfaces -
At last a new C# operator that can be used to define that class should be explained.
It is the “ is “ operator. Look at the following piece of code:
if(nodeC is INode)
Console.WriteLine("nodeC is object of INode type");
else
Console.WriteLine("nodeC isn't object of INode type");
In example nodeC object was created as ClonableNode type, but when we run program "if
operator" returns true. It means that nodeC also is of INode type.
Share And Enjoy:These icons link to social bookmarking sites where readers can share and discover new web pages.
Keywords c# Interfaces, vb net interfaces, c# vb net, windows forms c#, visual studio net c#,
c# source code, c# net framework, c# sample code, c# web service, c# asp net,
visual studio c#, net compact framework c#, visual basic c#, c# dot net, microsoft net c#,
interfaces c#, c# compact framework, interfaces in c#
