Interface declaration syntax in C Sharp (C#)

Introduction

An interface in C# is like a promise that a class will have certain methods or properties. It helps organize code and makes sure different parts work well together.

When you want different classes to share the same set of methods or properties.

When you want to write code that can work with different types of objects in the same way.

When you want to separate what a class does from how it does it.

When you want to create a contract that multiple classes must follow.

When you want to make your code easier to test and maintain.

Syntax

C Sharp (C#)

interface InterfaceName
{
    // Method signatures
    ReturnType MethodName(ParameterList);
    
    // Property signatures
    PropertyType PropertyName { get; set; }
}

The keyword interface starts the declaration.

Interfaces only have method and property signatures, no actual code inside methods.

Examples

This interface says any class that uses it must have a Speak method.

C Sharp (C#)

interface IAnimal
{
    void Speak();
}

This interface requires a Wheels property and a Drive method.

C Sharp (C#)

interface IVehicle
{
    int Wheels { get; set; }
    void Drive();
}

This interface defines two methods for shapes to calculate area and perimeter.

C Sharp (C#)

interface IShape
{
    double Area();
    double Perimeter();
}

Sample Program

This program shows an interface IGreet with a method SayHello. Two classes, Person and Robot, implement this interface with their own versions of SayHello. The Main method calls these methods through the interface.

C Sharp (C#)

using System;

interface IGreet
{
    void SayHello();
}

class Person : IGreet
{
    public void SayHello()
    {
        Console.WriteLine("Hello from Person!");
    }
}

class Robot : IGreet
{
    public void SayHello()
    {
        Console.WriteLine("Beep boop, hello from Robot!");
    }
}

class Program
{
    static void Main()
    {
        IGreet person = new Person();
        IGreet robot = new Robot();

        person.SayHello();
        robot.SayHello();
    }
}

Important Notes

Interfaces cannot contain fields or constructors.

A class can implement multiple interfaces, helping organize different behaviors.

Interfaces help with writing flexible and testable code.

Summary

Interfaces define a contract with method and property signatures only.

Classes use interfaces to promise they have certain methods or properties.

This helps write organized, flexible, and reusable code.

Practice

1. What is the main purpose of an interface in C#?

easy

A. To define a contract with method and property signatures only

B. To implement all method bodies for a class

C. To store data like variables and constants

D. To create an instance of a class directly

Solution

1. Step 1: Understand what an interface is

   An interface only declares method and property signatures without implementations.

2. Step 2: Compare with other options

   Interfaces do not implement methods or store data; they define a contract for classes.

3. Final Answer:

   To define a contract with method and property signatures only -> Option A

4. Quick Check:

   Interface purpose = contract definition [OK]

Hint: Interfaces declare methods, they don't implement them [OK]

Common Mistakes:

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

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

easy

A. interface IMyInterface { void MyMethod(); }

B. class IMyInterface { void MyMethod(); }

C. interface IMyInterface() { void MyMethod(); }

D. interface IMyInterface[] { void MyMethod(); }

Solution

1. Step 1: Check the keyword and name format

   Interfaces use the keyword interface followed by the name without parentheses or brackets.

2. Step 2: Validate method declaration inside interface

   Methods inside interfaces have only signatures ending with semicolons, no bodies.

3. Final Answer:

   interface IMyInterface { void MyMethod(); } -> Option A

4. Quick Check:

   Correct interface syntax = interface IMyInterface { void MyMethod(); } [OK]

Hint: Use 'interface Name { }' without parentheses or brackets [OK]

Common Mistakes:

• Using class keyword instead of interface
• Adding parentheses after interface name
• Using brackets [] after interface name

3. What will be the output of the following code?

interface IExample { void Show(); }
class Demo : IExample {
  public void Show() { Console.WriteLine("Hello Interface"); }
}
class Program {
  static void Main() {
    IExample obj = new Demo();
    obj.Show();
  }
}

medium

A. Compilation error: Show method missing

B. Hello Interface

C. Runtime error: Cannot create interface instance

D. No output

Solution

1. Step 1: Understand interface implementation

   The class Demo implements IExample and provides the Show method.

2. Step 2: Analyze the Main method

   An object of Demo is created and assigned to an IExample reference, then Show() is called, printing the message.

3. Final Answer:

   Hello Interface -> Option B

4. Quick Check:

   Interface method call prints message [OK]

Hint: Interface methods must be implemented to avoid errors [OK]

Common Mistakes:

• Assuming interfaces can be instantiated directly
• Forgetting to implement interface methods
• Expecting no output without method body

4. Identify the error in the following interface declaration:

interface ITest {
  void Run() {}
}

medium

A. Missing semicolon after method declaration

B. Method name must be lowercase

C. Interface name must start with lowercase 'i'

D. Interfaces cannot have method bodies

Solution

1. Step 1: Check method declaration in interface

   Interfaces only declare method signatures without bodies (no curly braces).

2. Step 2: Validate other syntax rules

   Method names can be any case; interface names usually start with uppercase 'I'. Semicolon is required after signature.

3. Final Answer:

   Interfaces cannot have method bodies -> Option D

4. Quick Check:

   Interface methods = signatures only [OK]

Hint: No method bodies allowed inside interfaces [OK]

Common Mistakes:

• Adding method bodies inside interfaces
• Confusing naming conventions with syntax errors
• Omitting semicolon after method signature

5. You want to declare an interface IVehicle with two methods: Start() and Stop(). Which of the following is the correct way to declare it and implement it in a class Car?

hard

A. interface IVehicle { void Start(); void Stop(); }
class Car { public void Start() { } public void Stop() { } }

B. interface IVehicle { void Start() {} void Stop() {} }
class Car : IVehicle { }

C. interface IVehicle { void Start(); void Stop(); }
class Car : IVehicle { public void Start() { Console.WriteLine("Car started"); } public void Stop() { Console.WriteLine("Car stopped"); } }

D. interface IVehicle { void Start(); void Stop(); }
class Car : IVehicle { void Start() { } void Stop() { } }

Solution

1. Step 1: Declare interface with method signatures only

   IVehicle must declare Start() and Stop() without bodies.

2. Step 2: Implement interface methods publicly in class

   Car must implement both methods with public access and provide method bodies.

3. Step 3: Check other options for errors

   interface IVehicle { void Start() {} void Stop() {} } class Car : IVehicle { } has method bodies in interface (invalid). interface IVehicle { void Start(); void Stop(); } class Car { public void Start() { } public void Stop() { } } does not implement interface. interface IVehicle { void Start(); void Stop(); } class Car : IVehicle { void Start() { } void Stop() { } } implements methods but lacks public modifier, causing error.

4. Final Answer:

   Correct interface and class implementation with public methods -> Option C

5. Quick Check:

   Interface methods declared; class implements publicly [OK]

Hint: Interface methods need public implementation in classes [OK]

Common Mistakes:

• Adding method bodies inside interface
• Not implementing interface in class
• Omitting public modifier in class methods