As a response to the third question asked in the first article What really it differs an Interface from a class: Part I, I can say that also interfaces play others important roles. They can serve as a powerful tool to explore objects that have some common characteristics or/and behaviors within an extremely heterogeneous environment. To fully understand the issue, I give this example:
Currently, the biologists estimate at 1.750.000 the number of a live species described by the scientists. Animals are classified as follow:
| Specie |
Estimate number |
Samples |
| Arthropoda |
1 200 000 |
Insect, Spider, crab |
| Mollusca |
100 000 |
snail, mould, octopus |
| Nematoda |
90 000 |
Ascaris |
| Chordata |
47 200 |
mammals, fish, reptiles |
| Platyhelminthes |
15 000 |
tapeworm |
| Annellida |
15 000 |
lombric, leech |
| Cnidaires |
9 000 |
jellyfishes, Polyps |
| Echinodermata |
6 000 |
sea urchin, starfish |
| Porifera |
4 300 |
sponge |
Imagine that you are responsible to develop an application that helps scientists as a part of a given research department activities to improve some tasks. Even though it is an extremely heterogeneous environment to handle, there are common characteristics shared between some of them. Imagine now that there are some treatments that should be done only if a given animal is vertebrate. So, this characteristic could be shared between species regardless of their genres. The problem is how to deal with this creasy number of animals and species to extract the targeted sub group from the entire one. To do so, you should adopt an interface programming concept, yes interface again!!!
Given that you have this situation:
![]()
Figure 12
Now, suppose that you want to handle special kind of vertebrate animals by injecting them some substances dose as a part of a given experience, you have to treat only the hominid category for example. You can do this through this mechanism:
First of all, all those species have to implement this interface
interface IVertebrate
{
/// <summary>
/// boolean indicates that this is an vertebrate animal
/// </summary>
bool IsVertebrate{get;}
}
Now, in order to treat the Hominid case you can use this code:
//Create a Species array to iterate throug them
Species [] Creatures = { new Human(), new Chimpanzee(), new Ourangoutan(), new Gazelle(), new Gnus()/* … and the list could continue so far */ };
/* use the for to iterate through Species objetcts then add only vertebrate
To the Vertebratelist */
ArrayList Vertebratelist = new ArrayList();
for (int i = 0; i < Species.Lenght; i++)
{
//If it is vertebrate then add it to the list
if (Creatures[i] is IVertebrate)
{
Vertebratelist.Add(Creatures[i]);
}
}
//use the for to iterate through objetcts
for (int i = 0;i < Vertebratelist.count; i++)
{
//If it is hominid then apply
if (Creatures[i] is IHominid)
{
//Do the injection process
}
}
If I summarize, first, I create a Species array then I extract all vertebrates from the whole group and put them into the Vertebratelist, in this case I'm sure that the entire invertebrate sub group will be ignored during the process. As a second step, I also filter the Hominid elements using the keyword is. At the other hand, Interfaces could be used as parameters to overload a given method. Interfaces could also be used as returned values in spite of their pure protocol nature. For example we can overload this method and use it to return an IHominid object if it is the case:
private IHominid GetHominid(Object obj)
{
if (obj is IHominid)
{
/* as is used to cast the object if
* its class implements the IHominid
interface */
return obj as IHominid;
}
else
{
return null ;
}
}
This function returns a hominid object. You can use it in the main bloc as follow:
//Create a IVertebrate array to iterate throug them
Ivertebrate [] Creatures = { new Human(), new Chimpanzee(), new Ourangoutan(), new Gazelle(), new Gnus() };
ArrayList list = new ArrayList();
for (int i = 0; i < Creatures.Length; i++)
{
if (Creatures[i] is IHominid)
{ list.Add(GetHominid(Creatures[i])); }
}
for (int i = 0; i < list.Count; i++)
MessageBox.Show(list[i].ToString());
As you see there are a lot of differences when comparing classes to interfaces, hope that you catch some principals ideas that enable you distinguish between them.
Good Dotneting!!!