Interface

Interface is exactly same as that of Abstract class with some differences. Another way to achieve abstraction in C#, is using interfaces. Interface can only have abstract methods (methods without body) inside it and it cannot be instantiated.

Syntax
interface InterfaceName {
    //Abstract methods
}

Abstract class Interface
It can have fields It cannot have fields
It can have normal methods(Methods with body) It cannot have normal methods(Methods with body)
Its members can have access modifiers Its members cannot have access modifiers
It can inherit from another abstract class or another interface It can inherit from another interface only and cannot inherit from an abstract class
While overriding abstract methods, Override keyword is mandatory While overriding abstract methods, Override keyword is not mandatory
Multiple inheritance is not possible Multiple inheritance is possible

TIP:
It is considered good practice to start with the letter "I" at the beginning of an interface, as it makes it easier for yourself and others to remember that it is an interface and not a class.

CODE

EG 1 . Creating 2 Interfaces called IShape and IObject and Inheriting to Class Circle.

interface IShape {
    //In interface no need to use Abstract keyword before abstract methods.
    double Area();
    double Volume();
    double Perimeter();
}

interface IObject {
    string message();
}

//Multiple Inheritance is possible when it comes to interface
class circle : IShape,IObject {
    public double radius, height;
    public double Area() {
        return Math.PI * radius * radius;
    }
    public double Volume() {
        return Area() * height;
    }
    public double Perimeter() {
        return 2 * Math.PI * radius;
    }
    public string message() {
        return "Welcome";
    }
}

class Program {
    static void Main(string[] args) {
        //Upcasting
        IShape i1 = new circle();
    }
}

CODE EXPLANATION
In the above code, we created 2 interfaces called IShape and IObject. Inside IShape we created 3 abstract methods called Area, Volume and Perimeter. Inside IObject we created 1 abstract method called message. Now we created a new normal class called circle where we implemented(When it comes to interface we should use term implement not inherit) both interfaces. The moment we implement system will start to show error because all the abstract method present inside interfaces must be overridden inside child class circle. In interface also upcasting plays a major role. Inside main method we used upcasting. We created a new instance of IShape called i1. Using i1 if we invoke Area method, system will go to its referred child class circle and its Area method will be executed.


Where to use Interface?
The purpose of an interface is same as that of abstract class.
If we are designing small, concise bits of functionality, we need to use interfaces. If we are designing large functional units, we need to use an abstract class. If we want to take advantage of multiple inheritace we can go with interface.

Exercises
1. Create an interface called IShape with 4 abstract methods Area(), Perimeter(), Volume() and Weight(). Now create 3 child classes called Rectangle, Triangle and Rhombus implement Shape abstract class.

(Click Here, For more exercises)