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.

Practice

1.

What does an interface in C# represent?

easy

A. A contract that defines methods a class must implement

B. A class that contains method implementations

C. A variable type that stores data

D. A method that runs automatically

Solution

1. Step 1: Understand the role of an interface

   An interface defines a set of method signatures without implementations.

2. Step 2: Compare with classes

   Classes implement interfaces by providing method bodies, fulfilling the contract.

3. Final Answer:

   A contract that defines methods a class must implement -> Option A

4. Quick Check:

   Interface = contract for methods [OK]

Hint: Interfaces define method rules, not code bodies [OK]

Common Mistakes:

• Thinking interfaces contain method code
• Confusing interfaces with classes
• Believing interfaces store data

2.

Which of the following is the correct way to declare an interface in C#?

?

easy

A. interface IAnimal { void Speak(); }

B. class IAnimal { void Speak(); }

C. interface IAnimal() { void Speak(); }

D. interface IAnimal { void Speak() {} }

Solution

1. Step 1: Check interface declaration syntax

   Interfaces use the keyword 'interface' followed by the name and method signatures without bodies.

2. Step 2: Identify correct method signature

   Method declarations in interfaces do not have bodies, so no curly braces after method.

3. Final Answer:

   interface IAnimal { void Speak(); } -> Option A

4. Quick Check:

   Interface syntax = keyword + method signatures [OK]

Hint: Interfaces have method signatures only, no bodies [OK]

Common Mistakes:

• Adding parentheses after interface name
• Using class keyword instead of interface
• Providing method bodies inside interface

3.

What will be the output of the following code?

interface IWorker { void Work(); }
class Employee : IWorker {
  public void Work() { Console.WriteLine("Employee working"); }
}
class Robot : IWorker {
  public void Work() { Console.WriteLine("Robot working"); }
}
class Program {
  static void Main() {
    IWorker w = new Robot();
    w.Work();
  }
}

medium

A. No output

B. Employee working

C. Compilation error

D. Robot working

Solution

1. Step 1: Identify the object type assigned to interface variable

   The variable 'w' is of type IWorker but assigned a new Robot instance.

2. Step 2: Determine which Work() method runs

   Calling w.Work() runs Robot's Work method, printing "Robot working".

3. Final Answer:

   Robot working -> Option D

4. Quick Check:

   Interface variable calls actual object's method [OK]

Hint: Interface calls method of assigned object's class [OK]

Common Mistakes:

• Assuming interface variable calls Employee method
• Expecting compilation error due to interface
• Thinking no output will print

4.

Identify the error in this code snippet:

interface IShape {
  double Area();
}
class Circle : IShape {
  public double Area() {
    return 3.14 * radius * radius;
  }
}

medium

A. Interface method cannot return double

B. Missing radius field or property in Circle class

C. Circle class should not implement IShape

D. Area method should be void

Solution

1. Step 1: Check Circle class members

   The method Area uses 'radius' but no radius variable or property is declared in Circle.

2. Step 2: Understand interface method return type

   Interface method returning double is valid; no error there.

3. Final Answer:

   Missing radius field or property in Circle class -> Option B

4. Quick Check:

   Undefined variable 'radius' causes error [OK]

Hint: Check all variables used are declared [OK]

Common Mistakes:

• Thinking interface methods can't return values
• Believing class can't implement interface
• Assuming method return type must be void

5.

You want to create a system where different devices can Start() and Stop() but each device does it differently. How should you use interfaces to design this?

hard

A. Create a base class Device with Start and Stop methods and inherit it

B. Write Start and Stop methods directly in each device class without interface

C. Define an interface IDevice with Start and Stop methods, then implement it in each device class

D. Use abstract classes only, no interfaces

Solution

1. Step 1: Understand interface purpose

   Interfaces define a contract for methods without implementation, perfect for different device behaviors.

2. Step 2: Apply interface to devices

   Define IDevice with Start and Stop, then each device class implements these methods with its own details.

3. Final Answer:

   Define an interface IDevice with Start and Stop methods, then implement it in each device class -> Option C

4. Quick Check:

   Interface = shared method rules, different implementations [OK]

Hint: Use interfaces for shared method names, different code [OK]

Common Mistakes:

• Using base class limits flexibility
• Skipping interface loses contract benefits
• Confusing abstract classes with interfaces