Why interfaces are needed in C Sharp (C#) - Visual Breakdown

Concept Flow - Why interfaces are needed

Define Interface

↓

Implement Interface in Classes

↓

Use Interface Type to Call Methods

↓

Swap Implementations Easily

↓

Flexible and Consistent Code

Interfaces define a contract that classes follow, allowing flexible and consistent use of different implementations.

Execution Sample

C Sharp (C#)

interface IAnimal {
    void Speak();
}

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

class Cat : IAnimal {
    public void Speak() { Console.WriteLine("Meow"); }
}

IAnimal animal = new Dog();
animal.Speak();

This code shows an interface IAnimal with Speak method, implemented by Dog and Cat classes, and usage via interface type.

Execution Table

Step	Action	Object Type	Method Called	Output
1	Create Dog instance	Dog	N/A	N/A
2	Assign Dog to IAnimal variable	Dog	N/A	N/A
3	Call Speak() on IAnimal variable	Dog	Speak()	Woof
4	Change IAnimal variable to Cat instance	Cat	N/A	N/A
5	Call Speak() on IAnimal variable	Cat	Speak()	Meow
6	End of execution	N/A	N/A	N/A

💡 Execution stops after calling Speak() on Cat instance and no more code to run.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
animal	null	Dog instance	Cat instance	Cat instance

Key Moments - 2 Insights

Why do we use the interface type (IAnimal) instead of the class type (Dog or Cat) for the variable?

Using the interface type allows the variable to hold any object that implements the interface, enabling flexible swapping of implementations as shown in steps 2 and 4 of the execution_table.

What happens if a class does not implement all methods of the interface?

The code will not compile because the class must fulfill the contract of the interface, ensuring consistent behavior as seen in the interface definition and class implementations.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output when Speak() is called on the Dog instance?

A Meow

B Woof

C Silent

D Error

💡 Hint

Check Step 3 in the execution_table where Speak() is called on Dog.

At which step does the variable 'animal' change from Dog to Cat?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the variable_tracker and execution_table rows for assignment changes.

If we add a new class Bird implementing IAnimal, how would the execution_table change?

A Add steps creating Bird instance and calling Speak() on it.

B No change needed, Bird cannot be used.

C Remove Dog and Cat steps.

D Change interface to include Fly() method.

💡 Hint

Interfaces allow adding new implementations without changing existing code, so new steps for Bird would be added.

Concept Snapshot

interface IName {
  void Method();
}

- Interfaces define method contracts.
- Classes implement interfaces.
- Use interface type for flexible code.
- Swap implementations easily.
- Ensures consistent behavior.

Full Transcript

Interfaces in C# define a set of methods that classes must implement. This allows different classes to be used interchangeably through the interface type. For example, Dog and Cat classes implement IAnimal interface with Speak method. We can assign a Dog or Cat object to an IAnimal variable and call Speak without knowing the exact class. This makes code flexible and consistent. The execution trace shows creating Dog, calling Speak outputs Woof, then switching to Cat and calling Speak outputs Meow. Using interfaces helps swap implementations easily and ensures classes follow the same method contract.

Practice

1. Why do we use interfaces in C# programming?

easy

A. To define a contract that classes must follow

B. To store data like variables

C. To create graphical user interfaces

D. To write comments in code

Solution

1. Step 1: Understand the purpose of interfaces

   Interfaces specify methods that a class must implement, acting like a contract.

2. Step 2: Compare other options

   Options B, C, and D describe unrelated concepts: data storage, UI design, and comments.

3. Final Answer:

   To define a contract that classes must follow -> Option A

4. Quick Check:

   Interface purpose = contract [OK]

Hint: Interfaces define required methods, not data or UI [OK]

Common Mistakes:

• Confusing interfaces with classes
• Thinking interfaces store data
• Mixing interfaces with UI design

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

easy

A. enum IExample { DoWork };

B. class IExample { void DoWork(); }

C. interface IExample { void DoWork(); }

D. struct IExample { void DoWork(); }

Solution

1. Step 1: Identify interface syntax

   In C#, interfaces are declared using the keyword interface followed by the name and method signatures.

2. Step 2: Check other options

   Options A, B, and C use enum, class, and struct keywords, which are not for interfaces.

3. Final Answer:

   interface IExample { void DoWork(); } -> Option C

4. Quick Check:

   Interface keyword = interface declaration [OK]

Hint: Look for 'interface' keyword to declare interfaces [OK]

Common Mistakes:

• Using class or struct instead of interface
• Missing method signature semicolon
• Confusing enums with interfaces

3. What will be the output of this C# code?

interface IAnimal { void Speak(); }
class Dog : IAnimal { public void Speak() { Console.WriteLine("Woof"); } }
class Cat : IAnimal { public void Speak() { Console.WriteLine("Meow"); } }
static void Main() {
  IAnimal animal = new Dog();
  animal.Speak();
  animal = new Cat();
  animal.Speak();
}

medium

A. Meow Woof

B. Woof Meow

C. Woof Woof

D. Meow Meow

Solution

1. Step 1: Understand interface usage

   The variable animal is of type IAnimal and first assigned a Dog object, so calling Speak() prints "Woof".

2. Step 2: Change object and call method again

   animal is then assigned a Cat object, so calling Speak() prints "Meow".

3. Final Answer:

   Woof Meow -> Option B

4. Quick Check:

   Interface variable calls method of assigned object [OK]

Hint: Interface variable calls method of current object type [OK]

Common Mistakes:

• Assuming interface variable fixes method output
• Mixing order of outputs
• Forgetting to implement interface methods

4. Identify the error in this code snippet:

interface IVehicle { void Drive(); }
class Car : IVehicle { }

medium

A. Car class should be abstract

B. Interface IVehicle cannot be empty

C. Drive() method should have a body in interface

D. Car class must implement Drive() method

Solution

1. Step 1: Check interface implementation rules

   A class implementing an interface must provide bodies for all interface methods.

2. Step 2: Analyze given code

   Car class implements IVehicle but does not define Drive(), causing a compile error.

3. Final Answer:

   Car class must implement Drive() method -> Option D

4. Quick Check:

   Implement all interface methods [OK]

Hint: Implement all interface methods in the class [OK]

Common Mistakes:

• Thinking interface methods have bodies
• Assuming empty class is valid implementation
• Confusing abstract class requirement

5. You want to write a method that accepts any object that can be saved to a database. Which approach best uses interfaces to achieve this?

hard

A. Define an interface ISaveable with method Save(), then accept ISaveable parameter

B. Use object type parameter and check type inside method

C. Create a base class Saveable and inherit from it

D. Write separate methods for each class type

Solution

1. Step 1: Understand interface benefits

   Interfaces allow different classes to share a common method signature, enabling polymorphism.

2. Step 2: Analyze options for flexibility and maintainability

   Define an interface ISaveable with method Save(), then accept ISaveable parameter uses an interface ISaveable with Save() method, allowing any class implementing it to be passed in.

3. Step 3: Compare other options

   Use object type parameter and check type inside method uses object and type checks, which is less clean. Create a base class Saveable and inherit from it uses inheritance, which is less flexible. Write separate methods for each class type duplicates code.

4. Final Answer:

   Define an interface ISaveable with method Save(), then accept ISaveable parameter -> Option A

5. Quick Check:

   Interfaces enable flexible method parameters [OK]

Hint: Use interface parameters for flexible method inputs [OK]

Common Mistakes:

• Using object and type checks instead of interfaces
• Relying only on inheritance
• Writing duplicate methods for each type