How do interfaces work in C#?

An interface defines a contract that will be implemented by a class or structure. It can contain methods, properties, events, and indexers. An interface is similar to a class, except that it does not hold any data and only specifies the behavior that it can perform (or, more accurately, the behavior that the class that implements it can perform).

A class can implement a behavior or more interfaces. To implement an interface member, a class should have public members with the same method definition as the interface members, i.e. the same name and signature.

For example, IComparer is an interface defined in the System.Collections namespace that defines a contract for methods that compare two objects. The Car class implements the IComparer interface

public interface IDriver{
   void Drive();
}
public class Car : IDriver{
   public string Name { get; set; }

   public int Speed { get; set; }
   public void Drive(){
      Console.WriteLine($"{Name}: {Speed}");
   }
}

All members on the interface are implicitly abstract and do not have any implementation details. All interface members are public. Access modifiers cannot be used with interface members. A class that implements an interface must provide public methods that implement the interface.

Interfaces can extend other interfaces, for example -

public interface IPerformer { void Perform(); }
public interface ISinger : IPerformer{
   void Sing();
}

Interfaces allow you to include behavior from multiple sources in a single class. Since C# does not allow multiple inheritance like C, interfaces are a way to implement multiple inheritance in C#.

One disadvantage of interfaces is that they are less flexible than classes when you use them to expose an API. When you change the contract of an interface, all classes that implement the interface break and need to be updated to implement the interface.

Example

Real-time demonstration

using System;
class Program{
   static void Main(){
      var carOne = new Car { Name = "Honda", Speed = 100 };
      var carTwo = new Car { Name = "Toyota", Speed = 70 };
      carOne.Drive();
      carTwo.Drive();
   }
}
public interface IDriver{
   void Drive();
}
public class Car : IDriver{
   public string Name { get; set; }
   public int Speed { get; set; }
   public void Drive(){
      Console.WriteLine($"{Name}: {Speed}");
   }
}

Output

Honda: 100
Toyota: 70

The above is the detailed content of How do interfaces work in C#?. For more information, please follow other related articles on the PHP Chinese website!