Interface Class In C#.NET

Whenever I tried to learn about what is Interface class the only answer I found was - Interface class is the contract between the parent and its child class where the parent is the interface class and its child class makes a promise to its parent that it will implement all of interface class features in the explanation. That is something like,

interface class IClass {
    public void SomeMethod();
public class MyClass: IClass {
    public void SomeMethod() {
        //Detail Implementation of the method
    public void SomeOtherMethod() {
        //Detail Implementation of the method

In the above example, the first character I in the name of the Interface class is the naming convention or let's say a rule that the interface class name should start with I.

The above example is an explanation of what we said in the initial definition of the interface class - and we also have an extra method name SomeOtherMethod() in MyClass that is to tell you guys that we can implement some extra methods as well in the child class but it is necessary to define Interface class methods in the child class when you are implementing the interface or It will give you an error.

In Short,

"We declare the function in the Interface class then implement that interface on the actual class get an error and then provide the explanation of the function in the actual class to avoid that error".

Here are a few questions 🙋,

Q: Can't we directly implement the method into the actual class without the involvement of the interface class?

Ans: Yes we can, and this is what we do all the time - but there are some special scenarios where we involve the interface class.

Q: Why do we use interface class?

Ans: I think I should clear it up with an example first -- Let's say there is the rule of thumb no matter what kind of machine you have. It should have a button to start it and the user should be unaware of all the details of a button that how it works internally. So here we will create an interface IMachine with the method StartMachine(). Now, whenever we will create something which has a machine we will like to impose this rule on that thing although that thing can have a lot of different features, having a StartMachine() system is important. To implement this feature we will implement this interface class on that machine class. Now look I am going to create two new things a Car and a WaterPump both have a machine, internally they work in different ways but both have the option to start a machine. How Interface will implement and how things will become easy look at the example 👇

interface IMachine {
    public void StartMachine();
public class Car: IMachine {
    public void StartMachine() {
    public void StartCarEngine() {
        Console.WriteLine("This Will start the car");
public class WaterPump: IMachine {
    public void StartMachine() {
    public void PlugMotorIntoSwitch() {
        Console.WriteLine("This Will start the Waterpump");
public class Program {
    public static void Main() {
        IMachine myMachine = new Car();
        IMachine myOtherMachine = new WaterPump();

The code above has an IMachine interface, a Car class, and a WaterPump class. The Car and WaterPump classes are implementing the interface so these classes must define the StartMachine() method and they have other methods as well we don't care about those for now.

Look how the interface class helped us in the Main() method. We are simply putting the objects of WaterPump and Car class into the Interface class variable and calling the same function for both classes through Interface without knowing about how car and waterpump start internally - The point is we don't need to learn different ways.




to start the machine of the car and waterpump we simply use our interface to Start machine and interface is taking care of the rest of the things we are simply calling StartMachine() for both car and waterpump although the method of getting start is different.