C# Interface

Last modified on: October 19, 2024

<h3>C# Interface: A Comprehensive Overview</h3>
<p>An interface in C# is a contract that defines a set of methods, properties, events, or indexers that a class must implement. Interfaces are a fundamental part of object-oriented programming and play a crucial role in achieving abstraction and polymorphism. This guide will cover what interfaces are, how to implement them, and best practices.</p>
<hr />
<h3>1. <strong>What is an Interface?</strong></h3>
<p>An interface is a reference type that defines a contract for classes or structs. It specifies what methods and properties a class must implement, but it does not provide any implementation for them. This allows different classes to implement the same interface in different ways.</p>
<hr />
<h3>2. <strong>Defining an Interface</strong></h3>
<p>To define an interface in C#, use the <code>interface</code> keyword followed by the interface name. By convention, interface names often start with the letter "I".</p>
<h4>Example: Defining an Interface</h4>
<pre class="language-csharp"><code>public interface IDrawable // Defining an interface
{
    void Draw(); // Method signature
    double GetArea(); // Another method signature
}
</code></pre>
<p>In this example, <code>IDrawable</code> is an interface with two method signatures: <code>Draw</code> and <code>GetArea</code>.</p>
<hr />
<h3>3. <strong>Implementing an Interface</strong></h3>
<p>A class that implements an interface must provide concrete implementations for all the methods and properties defined in the interface.</p>
<h4>Example: Implementing an Interface</h4>
<pre class="language-csharp"><code>public class Circle : IDrawable // Implementing the interface
{
    public double Radius { get; set; }

public Circle(double radius)
    {
        Radius = radius;
    }

public void Draw() // Implementation of Draw method
    {
        Console.WriteLine("Drawing a circle.");
    }

public double GetArea() // Implementation of GetArea method
    {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle : IDrawable // Another implementation
{
    public double Width { get; set; }
    public double Height { get; set; }

public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }

public void Draw() // Implementation of Draw method
    {
        Console.WriteLine("Drawing a rectangle.");
    }

public double GetArea() // Implementation of GetArea method
    {
        return Width * Height;
    }
}
</code></pre>
<p>In this example, both <code>Circle</code> and <code>Rectangle</code> classes implement the <code>IDrawable</code> interface. Each class provides its own implementation for the <code>Draw</code> and <code>GetArea</code> methods.</p>
<hr />
<h3>4. <strong>Using Interfaces</strong></h3>
<p>You can use interfaces to create variables that can hold objects of any class that implements that interface. This promotes flexibility and enables polymorphism.</p>
<h4>Example: Using Interfaces</h4>
<pre class="language-csharp"><code>public class Program
{
    public static void Main(string[] args)
    {
        IDrawable myCircle = new Circle(5);
        myCircle.Draw(); // Output: Drawing a circle.
        Console.WriteLine($"Area of Circle: {myCircle.GetArea()}"); // Output: Area of Circle: 78.53981633974483

IDrawable myRectangle = new Rectangle(4, 6);
        myRectangle.Draw(); // Output: Drawing a rectangle.
        Console.WriteLine($"Area of Rectangle: {myRectangle.GetArea()}"); // Output: Area of Rectangle: 24
    }
}
</code></pre>
<p>In this example, both <code>myCircle</code> and <code>myRectangle</code> are declared as <code>IDrawable</code> types, allowing them to reference any object that implements the <code>IDrawable</code> interface.</p>
<hr />
<h3>5. <strong>Multiple Interface Implementation</strong></h3>
<p>C# allows a class to implement multiple interfaces. This is useful for creating classes that share behavior across different types.</p>
<h4>Example: Multiple Interface Implementation</h4>
<pre class="language-csharp"><code>public interface IMovable
{
    void Move();
}

public interface IRotatable
{
    void Rotate();
}

public class Wheel : IMovable, IRotatable // Implementing multiple interfaces
{
    public void Move()
    {
        Console.WriteLine("The wheel is moving.");
    }

public void Rotate()
    {
        Console.WriteLine("The wheel is rotating.");
    }
}

// Using the Wheel class
public class Program
{
    public static void Main(string[] args)
    {
        Wheel myWheel = new Wheel();
        myWheel.Move();   // Output: The wheel is moving.
        myWheel.Rotate(); // Output: The wheel is rotating.
    }
}
</code></pre>
<p>In this example, the <code>Wheel</code> class implements both <code>IMovable</code> and <code>IRotatable</code> interfaces.</p>
<hr />
<h3>6. <strong>Interface Inheritance</strong></h3>
<p>Interfaces can inherit from other interfaces. This allows you to create more complex interfaces that build upon simpler ones.</p>
<h4>Example: Interface Inheritance</h4>
<pre class="language-csharp"><code>public interface IShape
{
    double GetArea();
}

public interface IDrawable : IShape // Inheriting from IShape
{
    void Draw();
}

public class Triangle : IDrawable
{
    public double Base { get; set; }
    public double Height { get; set; }

public Triangle(double baseLength, double height)
    {
        Base = baseLength;
        Height = height;
    }

public void Draw()
    {
        Console.WriteLine("Drawing a triangle.");
    }

public double GetArea()
    {
        return 0.5 * Base * Height;
    }
}

// Using the Triangle class
public class Program
{
    public static void Main(string[] args)
    {
        IDrawable myTriangle = new Triangle(5, 10);
        myTriangle.Draw(); // Output: Drawing a triangle.
        Console.WriteLine($"Area of Triangle: {myTriangle.GetArea()}"); // Output: Area of Triangle: 25
    }
}
</code></pre>
<p>In this example, the <code>IDrawable</code> interface inherits from the <code>IShape</code> interface, and the <code>Triangle</code> class implements both.</p>
<hr />
<h3>Conclusion</h3>
<p>Interfaces in C# are powerful tools for achieving abstraction and polymorphism. By defining a contract for classes to implement, interfaces allow for flexible and maintainable code that adheres to object-oriented principles. Understanding how to define and implement interfaces is essential for any C# developer.</p>

Web Technology View More