What is an Interface in C#

Multiple inheritence in .Net

Microsoft .NET framework does not provide support for multiple inheritance, primarily due to the inherent ambiguity that arises when the compiler encounters situations where it needs to determine the appropriate implementation of a virtual method from multiple parent classes. To address this challenge, Microsoft introduced the concept of interfaces as a viable solution for achieving similar functionality as multiple inheritance.

While .NET enforces the restriction of single inheritance for classes, developers have the flexibility to implement multiple interfaces in a single class. This approach allows for the inclusion of desired behavior and contracts from multiple sources without encountering the complexities and potential conflicts associated with multiple inheritance. By using interfaces, developers can attain code modularity, promote reusability, and establish clear contracts between components, while adhering to the single inheritance model enforced by the .NET framework.

Interface in C#

An interface in the context of object-oriented programming serves as a blueprint or specification defining a set of class members without providing an implementation. It represents a reference type and exclusively comprises abstract members, including methods, events, and properties. Interfaces solely declare the members without implementing them, making them distinct from classes. Notably, interfaces do not support the inclusion of constants, data fields, constructors, destructors, or static members. Moreover, all member declarations within an interface are implicitly public, indicating that they can be accessed by any implementing class.

Interface sample
interface Student { void getInfo(); } class School : Student { // Explicit interface member implementation: void Student.getInfo() { // Method implementation. } static void Main() { // Declare an interface instance. Student obj = new School(); // Call the member. obj.getInfo(); } }


To grasp the concept of an interface, it can be likened to an abstract class that solely consists of pure virtual functions. The actual implementation of these methods is carried out in the classes that implement the interface. By adhering to an interface, classes can exhibit consistent behavior while allowing flexibility for different implementation approaches. This design pattern promotes modularity, code reuse, and the establishment of contracts between components.