Interface as contract mental model in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Interface as contract mental model

Define Interface

↓

Interface specifies methods

↓

Class implements Interface

↓

Class must provide all methods

↓

Use class via Interface reference

↓

Call methods guaranteed by Interface

An interface defines a set of methods as a contract. Classes that implement the interface must provide those methods. This ensures consistent behavior when using the class through the interface.

Execution Sample

C Sharp (C#)

using System;

interface IAnimal {
    void Speak();
}

class Dog : IAnimal {
    public void Speak() { Console.WriteLine("Woof"); }
}

class Program {
    static void Main() {
        IAnimal pet = new Dog();
        pet.Speak();
    }
}

Defines an interface IAnimal with Speak method, Dog class implements it, then calls Speak via interface reference.

Execution Table

Step	Action	Evaluation	Result
1	Define interface IAnimal with Speak()	Interface created	IAnimal contract established
2	Define class Dog implementing IAnimal	Dog must implement Speak()	Dog class ready with Speak()
3	Create Dog instance and assign to IAnimal pet	pet references Dog object	pet is Dog instance
4	Call pet.Speak()	Dog.Speak() runs	Output: Woof
5	End of program	No more actions	Program terminates

💡 Program ends after calling Speak method on pet instance

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
pet	null	Dog instance	Dog instance	Dog instance

Key Moments - 3 Insights

Why must the Dog class implement the Speak method?

Because the interface IAnimal requires Speak(), the Dog class must provide it to fulfill the contract (see execution_table step 2).

What happens if we try to call a method not in the interface via the pet variable?

You cannot call methods not declared in the interface through the interface reference pet, since the contract only guarantees those methods (see execution_table step 4).

Why do we use the interface type IAnimal to hold the Dog instance?

Using the interface type ensures we only rely on the contract methods, allowing flexibility to swap different implementations later (see execution_table step 3).

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what output is produced when pet.Speak() is called?

A Meow

B Woof

C Error

D No output

💡 Hint

Check the Result column at step 4 in execution_table

At which step does the Dog class fulfill the interface contract by implementing Speak()?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the Action and Evaluation columns in execution_table step 2

If we assign a new class Cat implementing IAnimal to pet, what changes in variable_tracker?

A pet becomes null

B pet remains Dog instance

C pet changes to Cat instance

D pet becomes interface type only

💡 Hint

Variable tracker shows pet holds the instance assigned (see After Step 3)

Concept Snapshot

Interface defines method signatures as a contract.
Classes implementing interface must provide all methods.
Use interface type to hold instances for flexible code.
Calling methods via interface ensures contract compliance.
Interfaces enable swapping implementations easily.

Full Transcript

This visual trace shows how an interface acts as a contract in C#. First, the interface IAnimal is defined with a Speak method. Then, the Dog class implements IAnimal and provides the Speak method. Next, a Dog instance is created and assigned to a variable of type IAnimal named pet. When pet.Speak() is called, the Dog's Speak method runs and outputs 'Woof'. The variable tracker shows pet holds the Dog instance throughout. Key points include that the Dog class must implement Speak to fulfill the interface contract, and that using the interface type for pet allows flexible use of different animal classes. The quizzes test understanding of output, contract fulfillment, and variable assignment. This helps beginners see how interfaces guarantee certain methods and enable flexible, consistent code design.