In the previous article What's really differs an Interface from a class?: Part I I tried to distinguish the interface concept from the class concept by studying and parsing each one from a pure nature point of view and I tried to put the focus on first concept as it doesn't already clear for some people. In this article, I will respond to the second question posed in the previous one.

Compare the Interface function to the class function:

Generally classes including abstract classes serve as base model to other classes those inherit them and extend them through overriding members. Especially, abstract classes are perfect tools to generate new derived types, at the other hand, interfaces serve as bridge between different types even they are heterogeneous and I mean that they don't belong to the same family each others. Although the class serves to create new derived types, interfaces provide more functions. To better understand the diver services provided by both classes and interfaces let take a look at this example. Imagine an abstract class Hominid that serves as a base model to derived classes or types. This is a hominid representation.

classHomini

{

publicabstractstring Category{get; set;}

publicabstractuint Age{get; set;}

publicabstractuint Height{get; set;}

publicabstractuint Weight{get; set;}

publicabstractvoid Behaviour ();}

Given that those derived classes are Human, Chimpanzee and orangutan. We can implement them as follow

The human class:

public classHuman:Hominid

{

public Human()

: base()

{ }

privatestring _Category;

publicoverridestring Category

{

get

{

return _Category;

}

set

{

_Category = value;

}

}

privateuint _Age;

publicoverrideuint Age

{

get

{

return _Age;

}

set

{

_Age = value;

}

}

privateuint _Height;

publicoverrideuint Height

{

get

{

return _Height;

}

set

{

_Height = value;

}

}

privateuint _Weight;

publicoverrideuint Weight

{

get

{

return _Weight;

}

set

{

_Weight = value;

}

}

publicoverridevoid Behaviour()

{

Console.WriteLine("I'm a human");

Console.ReadKey(true);

Console.Beep();

}

}

The Chimpanzee class:

publicclassChimpanzee:Hominid

{

public Chimpanzee()

: base()

{ }

privatestring _Category;

publicoverridestring Category

{

get

{

return _Category;

}

set

{

_Category = value;

}

}

privateuint _Age;

publicoverrideuint Age

{

get

{

return _Age;

}

set

{

_Age = value;

}

}

privateuint _Height;

publicoverrideuint Height

{

get

{

return _Height;

}

set

{

_Height = value;

}

}

privateuint _Weight;

publicoverrideuint Weight

{

get

{

return _Weight;

}

set

{

_Weight = value;

}

}

publicoverridevoid Behaviour()

{

Console.WriteLine("I'm a Chimpanzee");

Console.ReadKey(true);

Console.Beep();

}

}

The Orangutan class:

classOurangoutan

{

public Ourangoutan()

: base()

{ }

privatestring _Category;

publicoverridestring Category

{

get

{

return _Category;

}

set

{

_Category = value;

}

}

privateuint _Age;

publicoverrideuint Age

{

get

{

return _Age;

}

set

{

_Age = value;

}

}

privateuint _Height;

publicoverrideuint Height

{

get

{

return _Height;

}

set

{

_Height = value;

}

}

privateuint _Weight;

publicoverrideuint Weight

{

get

{

return _Weight;

}

set

{

_Weight = value;

}

}

publicoverridevoid Behaviour()

{

Console.WriteLine("I'm a Ourangoutan");

Console.ReadKey(true);

Console.Beep();

}

}

So the principal role of an abstract class is to specialize each of those derived types, I mean Human, Chimpanzee and the Orangutan. The relationship can be presented by the following diagram:

Figure 6

This is the principal function of the abstract class.

Now, Say that we have other creatures that share almost the same characteristics as the Hominid. Antelopes are best example in such case. Well, Gazelles and Gnus could be excellent Antelopes example. But the problem is although Antelopes share same characteristics as Hominids, they don't belong to them. Even in a C++ environment where the multi inheritance is allowed, we can't resolve such problem and improve this relationship between Hominid and Antelope.

Interfaces come and put an end to this problem, by extracting the common characteristics of the both creatures' categories and serve as bridge between them. In fact, interfaces have more functions than this but let begin with this first utility. Ok, the question now is how to accomplish the task within Visual Studio when you have already developed the hominids family?

The problem is solved by Visual studio as it extracts the right interface automatically for you via refactoring the code. You just follow the procedure as follow. First, browse to the Hominid class then select the Extract Interface menu item.

Figure 7

The following window appears and invites you to select the common members. Those members will be integrated within the interface core.

Figure 8

Press "Select all" as you will extract all the abstract class members then press OK. The interface will be generated automatically for you.

using System;

namespace myProject

{

interfaceIHominid

{

uint Age { get; set; }

void Behaviour();

string Category { get; set; }

uint Height { get; set; }

uint Weight { get; set; }

}}

Notice that the Hominid class implements now the new IHominid interface.

using System;

using System.Collections.Generic;

using System.Text;

namespace myProject

{

classHominid : myProject.IHominid

{

publicabstractstring Category{get; set;}

publicabstractuint Age{get; set;}

publicabstractuint Height{get; set;}

publicabstractuint Weight{get; set;}

publicabstractvoid Behaviour ();

}}

Now, design the Gazelle and the Gnus classes so that they implement the new interface each.

The visual studio also provides us a short hand to rapidly develop classes that implement interface. In fact when you type this code:

classGazelle:IHominid

{

}

The first letter of the interface is underlined as follow:

Figure 9

When you move the mouse over this line a drop down list will appears as bellow:

Figure 10

In fact, you are invited to implement all interface members either explicitly or implicitly. If classes implement members with same name or signature as within the interface then use explicit implementation to avoid conflicts between members whose have the same name and don't mark the interface members with access keys such as public, otherwise they will be shadowed by the class members. Else you can just implement your interface members implicitly. The following graph

Figure 11

As you see, all types share the same members, and this can not be possible without the interface concept that serves as a bridge within a heterogeneous environment. You shouldn't miss the Part III-What's really differs an Interface from a class? Within witch I will expose more utility provided by interfaces.

The author holds a master degree in NTIC specialized in software developement delivered by the high school of communication SUPCOM, he also holds a bachelor degree in finance delivered by the economic s... Read more