Interfaces: contracts for behaviour

Why interfaces?

A class can inherit from only one base class, but objects often have several unrelated abilities. A PDF report can be printed, emailed and saved. An interface describes one ability. Any class, from any family tree, can sign the contract by implementing it.

Declaring and implementing

public interface INotifier
{
    bool Send(string to, string message);
}

public class SmsNotifier : INotifier
{
    public bool Send(string to, string message)
    {
        Console.WriteLine($"SMS to {to}: {message}");
        return true;
    }
}

public class EmailNotifier : INotifier
{
    public bool Send(string to, string message)
    {
        Console.WriteLine($"Email to {to}: {message}");
        return true;
    }
}

Programming to an interface

var service = new OrderService(new SmsNotifier());
service.PlaceOrder("Asha", "98xxxxxx10");

public class OrderService
{
    private readonly INotifier _notifier;
    public OrderService(INotifier notifier) => _notifier = notifier;

    public void PlaceOrder(string customer, string phone)
    {
        // ... save the order ...
        _notifier.Send(phone, $"Thanks {customer}, your order is confirmed");
    }
}

Several interfaces at once

public interface IPrintable { string Print(); }
public interface IExportable { byte[] ToPdf(); }

public class Invoice : IPrintable, IExportable
{
    public string Print() => "Invoice #2041";
    public byte[] ToPdf() => Array.Empty<byte>();   // placeholder
}

Built-in interface 1: IComparable<T>

Array.Sort and List.Sort need to know how to order your objects. Implement IComparable<T>: CompareTo returns a negative number if this comes first, 0 if equal, and a positive number if this comes after.

var list = new List<Student> { new("Ravi", 72), new("Asha", 91), new("Meena", 85) };
list.Sort();
foreach (var s in list) Console.WriteLine($"{s.Name} {s.Marks}");

public class Student : IComparable<Student>
{
    public string Name { get; }
    public int Marks { get; }
    public Student(string name, int marks) { Name = name; Marks = marks; }

    // higher marks first
    public int CompareTo(Student? other) => other is null ? -1 : other.Marks.CompareTo(Marks);
}

Built-in interface 2: IDisposable and using

Some objects hold resources outside .NET's memory: open files, network connections, database connections. They implement IDisposable, which has one method, Dispose(), that releases the resource. A using statement calls Dispose automatically at the end, even if an exception happens.

using (var writer = new StreamWriter("log.txt"))
{
    writer.WriteLine("Started");
}   // writer.Dispose() runs here: the file is closed

using var reader = new StreamReader("log.txt");   // C# 8 using declaration
Console.WriteLine(reader.ReadLine());            // disposed at the end of the scope

Built-in interface 3: IEnumerable<T>

Anything that can be looped with foreach implements IEnumerable<T>: arrays, List<T>, Dictionary and more. LINQ (module 6) is built on it. Taking IEnumerable<T> as a parameter lets callers pass any of these.

Default interface methods (C# 8), briefly

An interface may give a member a default body, so adding a new member later does not break every existing class. It is mainly used by library authors. In your own code, keep interfaces small and simple.

Abstract class or interface?

Common mistakes and fixes

• Huge interfaces with 20 members: classes must implement all of them. Split them into small, focused interfaces.
• Forgetting public on the implementing method: the class method must be public to implement an interface member implicitly.
• Not disposing: a StreamWriter that is never disposed may not write all its data. Use using.
• Creating an interface for every class "just in case": add one when you have two implementations or need a fake for testing.