Derived Interfaces
This topic contains and tries to cover following subjects:
- Explanation of Derived Interfaces in C#
- Syntax of derived Interface declaration in C#
- Why derived Interfaces are used
- Practical example of derived Interface in a console application of Visual Studio 2008
Articles provides solution to following questions and issues:
- What is derived Interface in C#?
- Why derived Interfaces are used in C#?
- Where derived Interfaces are used in C#?
- How to create a base Interface as template for inheriter Interfaces
Brief Explanation of Interfaces in C#
Interfaces are some sort of Class, similar to the Abstract Classes (with difference Abstract Classes can implement its methods-functions, Interfaces can not.). Idea behind an Interface is to create a Class that can tell to inheriter Class to implement certain methods or functions. It is some sort of contract between the Interface and inheriter Class.
Explanation of derived Interfaces in C#
Derived Interfaces work similar to the derived Class. When an Interface inherits a base Interface, Classes which implements derived Interface have to implement the method of base Interface also. Why? Because base Interface method became contract that derived Class which implements derived Class has to follow.
Syntax of derived Interface declaration in C#, and implementation in inheriter-Contracted Class
In order to declare an Interface, following syntax is used:
public interface I_baseInterface
{
void FN_base_Interface_Method_1();
}
public interface I_derivedInterface : I_baseInterface
{
void FN_derived_Interface_Method_1();
void FN_derived_Interface_Method_2();
}
public class CL_aClass: I_derivedInterface
{
void FN_base_Interface_Method_1()
{} //Notice that Class which inherits derived Interface has to implement base Interface
methods too...///
void FN_derived_Interface_Method_1()
{}
void FN_derived_Interface_Method_2()
{}
}
Example of derived Interface declaration and implementation within inheriter Class in C#
Following example of Interface is created in Visual Studio 2008 as console application. It indicates how to declare an Interface and implement in inheriter Class.
namespace NS_HRapplication
{
//declare an base Interface as employee Template...///
interface I_employee
{
void FN_displaySalary();
}
//declare an Interface for employee actions Template and inherit Base Interface I_employee..///
interface I_employeeActions: I_employee
{
void FN_leaves();
void FN_retires();
void FN_marries();
}
//declare a base Class as employee Template and implement derived Interface...///
class CL_employees : I_employeeActions
{
//add a field for employee Name...///
public string V_employeeName;
//We implement our derived Interface methods now, and adding all methods of derived Interface....//
/ public void FN_leaves()
{}
public void FN_retires()
{}
public void FN_marries()
{}
//following method implementation is required for base Interface...///
public void FN_displaySalary()
{
Console.WriteLine("her salary is 1000 euro...");
}
//end of Interface implementation...///
}
class CL_technicians : CL_employees
{
//we had not implemented our derived Interface methods here again. Our base Class implemented already...///
}
//another derived Class makes contract with base and derived Interface via inheriting base Class...///
class CL_engineers : CL_employees
{
//we had not implemented our derived Interface methods here again. Our base Class implemented already...///
}
class CL_x
{
static void Main(string [] args)
{
CL_technicians o_aTechnician = new CL_technicians();
o_aTechnician.V_employeeName = "helen";
//display salary of helen ...///
o_aTechnician.FN_displaySalary();
Console.ReadLine();
}
}
}
What happened in above code. We first declared an Interface and a derived Interface. We implemented derived Interface in our base Class "CL_employees". We created another Class for technician type employees and inherited base Class CL_employees to the "Cl_technicians". With inheritance, our technician Class gained method "FN_displaySalary". That method had been implemented in base Class. Contract had been provided by base Interface. CL_employees implemented only "I_employeeActions". With that implementation it also implemented automatically the base Interface which says to employee Class that it has to implement "FN_displaySalary". In chain:
- Base Interface tells derived Interface: "add my methods to the contract too"
- Derived Interface tells its implementer base Class: "implement all my methods which exist in contract: Interface is a contract that inheriter Classes have to implement all methods described in Interface"
- Base Class tells derived Class: I have implemented all method, and you can use them if you inherit from me"
- Derived Class objects automatically gain method as chain.
