C# Interfaces and Contracts: Ask for a Capability, Choose the Implementation

What you will understand

• Explain an interface as a capability contract rather than a concrete object.
• Read required method and getter declarations.
• Implement a contract explicitly on a class with public members.
• Use interface references, arrays and parameters without subtype switches.
• Supply a consumer dependency through a normal constructor.
• Distinguish compiler-checked signatures from written behavioral rules.
• Recognize multiple contracts and explicit interface implementation.
• Choose between an interface, abstract base and composition using the responsibility.

An interface says what a caller can ask for

Imagine a page that needs a message preview. It does not need to know every detail of the object creating that preview. It only needs two things: a channel name and a method that turns a supplied message into preview text. An interface names that small capability.

IMessagePreview declares Channel and Format. Think of it as a promise that an implementing object can answer those requests. The declaration does not create a formatter, store its message or send anything. A concrete class such as EmailPreview supplies the actual implementation.

In IMessagePreview preview = new EmailPreview(), the left side tells the compiler which contract the caller will use. The right side creates the object that fulfills it. There is one object, and preview holds a reference to it. This is the same identity idea you learned with base-class references.

The first program reads Channel and calls Format. Follow each use back to the public property and method in EmailPreview. Notice that no override keyword is needed for this ordinary interface implementation: the class is fulfilling an interface declaration, not overriding a virtual base-class method.

using System;

class Program
{
    static void Main()
    {
        IMessagePreview preview = new EmailPreview();
        Console.WriteLine(preview.Channel);
        Console.WriteLine(preview.Format("  Lesson ready  "));
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

Email
Email preview: Lesson ready

Read the declaration and implementation side by side

interface introduces a contract type. Prefixing its name with I, as in IMessagePreview, is a naming convention rather than a special compiler requirement. The method declaration string Format(string message); specifies a name, input type and result type, ending with a semicolon because this basic contract supplies no body.

string Channel { get; } requires a readable property. A consumer can read it through the interface but cannot assume a setter exists. The class may compute the channel or store it internally; the caller should not need to know how it is represented.

class EmailPreview : IMessagePreview explicitly states that the class implements the interface. Its ordinary implicit implementations are public and match the required members. A concrete class missing Channel, or supplying a private Format instead, does not fulfill this contract and fails compilation.

These examples use required instance members without default bodies. Modern C# also supports default interface implementations and advanced static abstract contracts. You do not need those features to understand this lesson, and their existence is why we do not claim that interfaces can never contain implementation code.

using System;

class Program
{
    static void Main()
    {
        IMessagePreview preview = new IncompletePreview();
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class IncompletePreview : IMessagePreview
{
    public string Format(string message)
    {
        return message;
    }
}

Select Run code to compile and execute this program.

Compilation fails: IncompletePreview does not implement IMessagePreview.Channel.

using System;

class Program
{
    static void Main()
    {
        IMessagePreview preview = new EmailPreview();
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    private string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    private string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

Compilation fails: a non-public Format method cannot implement the interface member implicitly.

Use an interface variable without confusing it with an instance

You cannot create new IMessagePreview(). The interface is not a concrete class with an instance constructor. Choose a concrete implementation and assign its reference to the interface variable. The consumer can then use only the members declared by that interface.

C# does not infer this interface relationship merely because a class happens to have Channel and Format members. LookAlike intentionally has similar members but omits : IMessagePreview, so assignment fails. A matching shape is not the same as a declared implemented contract here.

Changing from a concrete reference to an interface reference does not copy the object or erase its other capabilities. It selects the view used by that expression. If a concrete type has extra members, a caller using IMessagePreview should normally avoid depending on them; otherwise the supposedly interchangeable design is still tied to one implementation.

using System;

class Program
{
    static void Main()
    {
        IMessagePreview preview = new IMessagePreview();
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

Compilation fails: an instance of the interface IMessagePreview cannot be created.

using System;

class Program
{
    static void Main()
    {
        IMessagePreview preview = new LookAlike();
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class LookAlike
{
    public string Channel { get { return "Local"; } }
    public string Format(string message) { return message; }
}

Select Run code to compile and execute this program.

Compilation fails: LookAlike cannot implicitly convert to IMessagePreview.

Depend on the capability, then supply a concrete choice

Show(IMessagePreview preview) accepts the capability its work needs. Main can supply EmailPreview or SmsPreview. The helper calls Format on the supplied object instead of branching on concrete class names. Replacing the implementation should not require editing the consumer.

The same contract works in an array. Every element supports the requested members, so one foreach loop can render all previews. Output order follows the array order; the implementation behind each reference supplies its own channel and formatting. An empty array should produce no lines.

A consumer can also receive and store an interface in its constructor. PreviewCard does this and rejects a null dependency immediately. The caller chooses the concrete formatter, so the card does not create a fixed one internally. This is often called dependency injection, but the example is just normal constructor arguments, a field and delegation.

An interface does not choose an implementation automatically. Somewhere, such as Main, concrete objects still need to be created and connected. A dependency-injection framework can automate some wiring in larger applications, but it is not required for the language feature or the principle.

using System;

class Program
{
    static void Main()
    {
        Show(new EmailPreview());
        Show(new SmsPreview());
    }

    static void Show(IMessagePreview preview)
    {
        Console.WriteLine(preview.Format("Welcome"));
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

Email preview: Welcome
SMS preview: Welcome

using System;

class Program
{
    static void Main()
    {
        IMessagePreview[] previews = { new EmailPreview(), new SmsPreview() };
        foreach (IMessagePreview preview in previews)
        {
            Console.WriteLine($"{preview.Channel} | {preview.Format("Ready")}");
        }
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

Email | Email preview: Ready
SMS | SMS preview: Ready

using System;

class Program
{
    static void Main()
    {
        PreviewCard card = new PreviewCard(new SmsPreview());
        Console.WriteLine(card.Render("Practice today"));
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

class PreviewCard
{
    private IMessagePreview preview;

    public PreviewCard(IMessagePreview preview)
    {
        if (preview is null)
        {
            throw new ArgumentNullException(nameof(preview));
        }
        this.preview = preview;
    }

    public string Render(string message)
    {
        return $"[{preview.Channel}] {preview.Format(message)}";
    }
}

Select Run code to compile and execute this program.

[SMS] SMS preview: Practice today

A contract includes meaning that the compiler cannot infer

The compiler checks that a required member exists with a compatible declaration. It cannot infer every promise about the returned text. A method that always returns TODO can satisfy the string signature while failing the feature. Syntax correctness and useful behavior need separate verification.

For our email and SMS preview pair, the written policy is simple: reject null, empty or whitespace-only messages; otherwise trim outside whitespace and preserve the remaining message after the channel prefix. Both implementations follow it so the consumer can rely on it. This differs from the prior polymorphism lesson’s simpler interpolation examples that allowed empty text.

Throw an argument exception before calling Trim on missing input. Main can handle a rejected message at an appropriate boundary; the lab execution tests catch expected failures to inspect them. A real delivery service would have further concerns such as recipients, retries and provider errors, none of which this local preview contract claims to implement.

The guided repair demonstrates another behavioral failure: accepting an interface argument and then overwriting it with a new fixed implementation. No keyword prevents that mistake. A focused test that supplies SmsPreview exposes whether the consumer truly respects its dependency.

Small interfaces can describe different capabilities on one object

A class can implement several interfaces, separated by commas. CombinedPreview can format a local message and describe itself through two small contracts. Two interface variables still refer to that same instance, as ReferenceEquals confirms.

This is not multiple inheritance of class instance state. A C# class has one direct base class but can implement multiple interfaces. Interfaces do not declare instance fields or instance constructors. Each implementing class decides where its data lives and how to establish valid state.

Keep contracts focused. A consumer that only renders a preview should not be forced to depend on unrelated file-writing or account-management operations. Multiple small capabilities are useful when responsibilities actually differ; creating an interface for every class without a caller need adds names without necessarily improving the design.

Explicit implementation is a second syntax option. IMessagePreview.Format names the contract on the member itself and does not use a public modifier. Callers access that member through the interface view. It can separate same-named contracts or keep a concrete public surface small, but it is still available to code that can use the interface and is not a secrecy mechanism.

using System;

class Program
{
    static void Main()
    {
        CombinedPreview concrete = new CombinedPreview();
        IMessagePreview preview = concrete;
        IDescribed described = concrete;
        Console.WriteLine(preview.Format("Ready"));
        Console.WriteLine(described.Describe());
        Console.WriteLine(object.ReferenceEquals(preview, described));
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

interface IDescribed
{
    string Describe();
}

class CombinedPreview : IMessagePreview, IDescribed
{
    public string Channel { get { return "Local"; } }
    public string Format(string message) { return $"Local preview: {message}"; }
    public string Describe() { return "A local demonstration formatter"; }
}

Select Run code to compile and execute this program.

Local preview: Ready
A local demonstration formatter
True

using System;

class Program
{
    static void Main()
    {
        PrivatePreview concrete = new PrivatePreview();
        IMessagePreview preview = concrete;
        Console.WriteLine(preview.Channel);
        Console.WriteLine(preview.Format("Ready"));
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class PrivatePreview : IMessagePreview
{
    string IMessagePreview.Channel { get { return "Explicit"; } }
    string IMessagePreview.Format(string message)
    {
        return $"Explicit preview: {message}";
    }
}

Select Run code to compile and execute this program.

Explicit
Explicit preview: Ready

Choose an interface for a capability and an abstract class for shared state

In the previous lesson, PracticeReport shared learner state, constructor validation and a rendering workflow. An abstract base class fit those related objects because they genuinely reused that base implementation and initialization. An interface cannot directly provide per-instance fields or an instance constructor for them.

IMessagePreview instead describes the capability a consumer needs without choosing one custom base class. Different types can fulfill it even if they already belong to different class hierarchies. A class can also derive from an abstract base and implement interfaces when both relationships are useful.

Ask two questions: what must the caller be able to request, and what implementation state must related types share? The first can suggest an interface; the second can suggest an abstract base. Composition can connect consumers and implementations regardless of that choice. These tools work together rather than forming a universal ranking of better and worse.

Do not add a framework, type switch or downcast just because the interface hides concrete details. That smaller view is often the point. If a consumer constantly needs extra subtype-specific members, reconsider whether its contract expresses the real responsibility.

Verify every implementation through the same caller

Test both preview implementations through IMessagePreview references. Use an ordinary message, a message with outside spaces, empty text, whitespace-only text and null. Both should preserve the same policy, with only the channel-specific prefix changing.

Change the message so hard-coded reference text cannot accidentally pass. Reverse the array to check output order and use an empty array to check that the consumer adds no fake previews. For PreviewCard, supply each implementation and verify that a null dependency is rejected during construction.

Also inspect the compilation boundaries: an incomplete implementation, non-public implicit method and undeclared look-alike type must fail where demonstrated. A concrete class with explicit members should be used through its interface view. These tests teach different rules; one successful reference program cannot prove all of them.

The lab completes the SMS behavior while leaving the consumer unchanged. It produces local text, not a sent email, SMS, stored message or provider integration. Next we move to enums, where small sets of named states make a different kind of contract easier to understand.

Guided repair: respect the supplied implementation

Show receives SmsPreview but prints Email preview because it replaces the supplied argument with a new EmailPreview. Repair the consumer so it respects the capability object selected by its caller.

using System;

class Program
{
    static void Main()
    {
        Show(new SmsPreview());
    }

    static void Show(IMessagePreview preview)
    {
        preview = new EmailPreview();
        Console.WriteLine(preview.Format("Ready"));
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

Email preview: Ready

Repair checkpoints

1. Remove preview = new EmailPreview() from Show.
2. Keep the IMessagePreview parameter and call its Format method.
3. Leave concrete selection at the call site.
4. Verify Show(new SmsPreview()) produces SMS preview: Ready.
5. Do not replace the mistake with a type switch or a forced cast.

using System;

class Program
{
    static void Main()
    {
        Show(new SmsPreview());
    }

    static void Show(IMessagePreview preview)
    {
        Console.WriteLine(preview.Format("Ready"));
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

SMS preview: Ready

Independent lab: interchangeable preview implementations

Complete two interchangeable preview implementations under one behavioral policy. Keep the interface and array consumer unchanged, then verify that every accepted message survives formatting.

Acceptance checklist

• Preserve IMessagePreview with its Channel getter and Format method.
• Keep each class explicitly declaring that it implements the interface.
• Keep required ordinary members public.
• Reject null, empty and whitespace-only messages with ArgumentException identifying message.
• Trim outside spaces and return the appropriate channel prefix followed by the remaining message.
• Replace the SMS placeholder with its actual message-based result.
• Leave the shared IMessagePreview[] loop unchanged; it must not branch on subtype names.
• Treat all output as local preview text with no message delivery.

using System;

class Program
{
    static void Main()
    {
        IMessagePreview[] previews = { new EmailPreview(), new SmsPreview() };
        foreach (IMessagePreview preview in previews)
        {
            Console.WriteLine(preview.Format("  Your practice is ready  "));
        }
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return "SMS preview: TODO";
    }
}

Select Run code to compile and execute this program.

Email preview: Your practice is ready
SMS preview: TODO

using System;

class Program
{
    static void Main()
    {
        IMessagePreview[] previews = { new EmailPreview(), new SmsPreview() };
        foreach (IMessagePreview preview in previews)
        {
            Console.WriteLine(preview.Format("  Your practice is ready  "));
        }
    }
}

interface IMessagePreview
{
    string Channel { get; }
    string Format(string message);
}

class EmailPreview : IMessagePreview
{
    public string Channel { get { return "Email"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"Email preview: {message.Trim()}";
    }
}

class SmsPreview : IMessagePreview
{
    public string Channel { get { return "SMS"; } }

    public string Format(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            throw new ArgumentException("A message is required.", nameof(message));
        }
        return $"SMS preview: {message.Trim()}";
    }
}

Select Run code to compile and execute this program.

Email preview: Your practice is ready
SMS preview: Your practice is ready

Changed-input checks

• Both implementations preserve Welcome after the correct prefix.
• Outside spaces are trimmed, while spaces inside a valid message remain.
• Empty, whitespace-only and null messages are rejected for message.
• Reversing the array reverses the output order.
• An empty interface array prints no lines.
• PreviewCard works with either implementation and rejects a null dependency.

Recap: capability, implementation and consumer

Identify the required members, the concrete implementation and the caller that selects it. Verify the behavioral policy as well as the signatures.

interface IMessagePreview

Declare the capability available to the consumer.

string Channel { get; }

Require readable channel information without promising a setter.

string Format(string message);

Require the basic formatting operation and its result type.

class EmailPreview : IMessagePreview

Declare that the class fulfills the interface.

public implementation

Ordinary implicit members that satisfy the basic contract.

constructor dependency

Receive the chosen implementation instead of constructing a fixed one inside the consumer.

multiple interfaces

Expose separate capabilities of the same object.

explicit interface member

Expose a particular implementation through its interface view.

Frequently asked questions

Next step and references

An interface describes a capability without choosing its concrete object. Implement the required members, supply the object at the boundary and keep the consumer focused on its contract. Tests verify the behavioral meaning that signatures alone cannot prove.

Next is C# Enums and Named States. You will represent a small set of states with clear names and validate values entering from outside the program.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

• Microsoft Learn: Interfaces, implementation and abstract-class comparison

Last updated: 27 October 2026.