16.6. Object Orientation in C#: Interfaces

Object orientation is a programming paradigm that uses "objects" - data structures consisting of data fields and methods together with their interactions - to design applications and computer programs. In C#, one of the fundamental concepts of object orientation is the interface.

Interfaces in C# are definitions of a contract. They declare a set of unimplemented methods, properties or events. A class or structure that implements the interface must provide an implementation for each member declared by the interface. Interfaces are used to achieve abstraction, loose coupling, and multiple inheritance.

Interface Definition

An interface is defined using the 'interface' keyword. By convention, interface names begin with a capital 'I'. Here is an example of a simple interface:

public interface IAnimal
{
    void Eat();
    void Sleep();
}

This interface defines two methods, Eat() and Sleep(), but does not provide any implementations for them. It is the responsibility of the classes that implement this interface to provide the implementation of these methods.

Interface Implementation

A class or structure implements an interface by providing an implementation for all of its members. A class can implement multiple interfaces. Here is an example of a 'Dog' class that implements the 'IAnimal' interface:

public class Dog : IAnimal
{
    public void Eat()
    {
        Console.WriteLine("Dog is eating.");
    }

    public void Sleep()
    {
        Console.WriteLine("Dog is sleeping.");
    }
}

In this example, the Dog class implements the IAnimal interface and provides the implementation for the Eat() and Sleep() methods.

Interfaces vs Abstract Classes

Interfaces are similar to abstract classes in C# in that they both provide a way to define a contract that derived classes must follow. However, there are some important differences. Abstract classes can provide method implementations, while interfaces cannot. Additionally, a class can implement multiple interfaces, but can only inherit from a single abstract class.

User Interfaces

Interfaces are especially useful for providing a high level of abstraction and for achieving loose coupling between classes. They allow you to define a contract that specifies what a class should do, but not how it should do it. This allows different classes to implement the same interface in different ways, which is a form of polymorphism.

Also, interfaces are the only way to achieve multiple inheritance in C#. A class can implement multiple interfaces, which allows it to inherit behaviors from multiple sources.

In summary, interfaces in C# are a powerful tool that enables abstraction, loose coupling, and multiple inheritance. They are an essential component of object-oriented programming in C# and are widely used in Unity game programming.

Next page of the Free Ebook:

23Object Orientation in C#: Constructors and Destructors

3 minutes