What really it differs an Interface from a class: Part III

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)







//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;




                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++)


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!!!