C# Interface

An interface is defined using the interface keyword, similar to a class. An Interface is a blueprint that outlines a group of methods, properties, events, or indexers that a class or struct must implement. Unlike classes, it contains only the declaration of the members. The implementation of the interface’s members will be given by a class that implements the interface implicitly or explicitly. There are some important points to remember, as mentioned below:

• Interfaces cannot have private members.
• By default, all the members of Interface are public and abstract.
• The interface will always be defined with the help of the keyword interface
• Interfaces cannot contain fields because they represent an implementation of data.
• We can achieve multiple inheritance with the interface but not with the classes.
• We can implement multiple interfaces in a single class separated by commas.

Example 1: Demonstrating the basic case for implementing the Interface.

// Demonstrate working of Interface  using System;   interface inter1 { // method having only declaration  // with no definition void display(); } // Implementing inteface in Geeks class Geeks : inter1 { // providing the body part of function  public void display() { Console.WriteLine("Demonstration of interface"); }  // Main Method public static void Main(String[] args) { Geeks t = new Geeks(); t.display(); } } 

Demonstration of interface 

Example 2: Implementation of interfaces and the use of polymorphism in C#

// Using Interfaces and Polymorphism using System; // interface declaration  interface Vehicle { // abstract method.  void speedUp(int a); } // class implements interface  class Bicycle : Vehicle { int speed; // Method increase speed  public void speedUp(int increment) { speed = speed + increment; } // Method check speed public void CheckSpeed() { Console.WriteLine("speed: " + speed); } } // class implements interface  class Bike : Vehicle { int speed;   // to increase speed  public void speedUp(int increment) { speed = speed + increment; } public void CheckSpeed() { Console.WriteLine("speed: " + speed); } } class Geeks { public static void Main(String[] args) { // creating an instance of Bicycle  // doing some operations  Bicycle bicycle = new Bicycle(); bicycle.speedUp(3); Console.WriteLine("Bicycle present state :"); bicycle.CheckSpeed(); // creating instance of bike.  Bike bike = new Bike(); bike.speedUp(4); Console.WriteLine("Bike present state :"); bike.CheckSpeed(); } } 

Bicycle present state : speed: 3 Bike present state : speed: 4 

Advantages of Interfaces

• Loose coupling: It is used to achieve loose coupling rather than concrete implementations, we can decouple classes and reduce interdependencies.
• Abstraction: Interface helps to achieve full abstraction.
• Maintainability: It helps to achieve component-based programming that can make code more maintainable.
• Multiple Inheritance: Interface used to achieve multiple inheritance and abstraction.
• Define architecture: Interfaces add a plug and play like architecture into applications.
• Modularity: Promote a cleaner and more modular design. By separating the definition of behavior from the implementation