What's really differs an Interface from a class?: Part II

The Orangutan class:

class Ourangoutan { public Ourangoutan() : base() { } private string _Category; public override string Category { get { return _Category; } set { _Category = value; } } private uint _Age; public override uint Age { get { return _Age; } set { _Age = value; } } private uint _Height; public override uint Height { get { return _Height; } set { _Height = value; } } private uint _Weight; public override uint Weight { get { return _Weight; } set { _Weight = value; } } public override void 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

{

interface IHominid

{

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

{

class Hominid : myProject.IHominid

{

public abstract string Category{get; set;}

public abstract uint Age{get; set;}

public abstract uint Height{get; set;}

public abstract uint Weight{get; set;}

public abstract void 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:

class Gazelle: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.