C# Interfaces, Composition, and Inheritance

ReminderService needs something that can send a message. It does not need to know whether delivery uses the console, email, SMS, or a test recorder. IMessageSender names that small capability through a method contract.

An interface contains member contracts that an implementing type must provide. A variable of interface type can refer to any conforming object, which lets calling code focus on what it can do rather than its concrete implementation.

ReminderService receives an IMessageSender in its constructor and stores it. This is composition: the service has a sender and delegates delivery to it. The collaborator is explicit, required, and replaceable without editing the reminder rules.

Composition is often safer than inheritance because relationships can vary independently. A Report can use a formatter and a destination without claiming a report is a formatter or destination. Small interfaces also allow tests to supply a fake or recording implementation.

class RecordingSender : IMessageSender
{
  public string LastRecipient { get; private set; }
  public string LastMessage { get; private set; }

  public void Send(string recipient, string message)
  {
      LastRecipient = recipient;
      LastMessage = message;
  }
}

A derived class inherits accessible members from a base class and can override virtual behavior. The important test is substitutability: code written for the base type should remain correct when given the derived type. Similar fields or a desire to reuse ten lines are not enough.

Deep inheritance trees couple types to base implementation details and make behavior difficult to locate. Use a base class when the abstraction is stable and shared implementation genuinely belongs to it. Otherwise prefer composition, an interface, or an ordinary helper method.

abstract class Shape
{
  public abstract double Area();
}

class Rectangle : Shape
{
  public double Width { get; }
  public double Height { get; }

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

  public override double Area()
  {
      return Width * Height;
  }
}

Use an interface when callers need a capability with multiple possible providers. Use composition when one object needs another to perform part of its work. Use inheritance when a true base abstraction exists and derived types preserve its promises. Use none of them when a simple method or concrete class is enough.

Adding an interface for every class creates extra files without flexibility. Add an abstraction at a boundary that varies, needs isolated testing, or represents a real domain capability. Concrete code is not a failure when there is only one stable implementation and no useful separation.