Understanding OOPS Concepts in C# with Simple Examples

Introduction

Object-Oriented Programming System (OOPS) is a programming approach that organizes software design around objects instead of functions and logic. C# is a fully object-oriented language and heavily uses OOPS concepts to build scalable, maintainable, and reusable applications.

For beginners, understanding OOPS is very important because almost all real-time .NET applications are built using these principles. In this article, we will learn the core OOPS concepts in C# with simple explanations and examples.

The four main pillars of OOPS are:

1. Encapsulation

2. Abstraction

3. Inheritance

4. Polymorphism

Additionally, we will also look at:

• Class and Object

• Interface

• Access Modifiers

1. Class and Object

A class is a blueprint of an object. An object is a real-world instance of a class.

Example

class Car
{
    public string Brand;
    public void Start()
    {
        Console.WriteLine("Car is starting...");
    }
}

class Program
{
    static void Main()
    {
        Car myCar = new Car();  // Object
        myCar.Brand = "BMW";
        myCar.Start();
    }
}

Output:

Car is starting...

Here, Car is a class and myCar is its object.

2. Encapsulation

Encapsulation means wrapping data and methods together and protecting data from outside access. It is achieved using private fields and public properties.

Example

class Account
{
    private int balance;

    public void SetBalance(int amount)
    {
        balance = amount;
    }

    public int GetBalance()
    {
        return balance;
    }
}

This ensures the balance cannot be modified directly.

3. Abstraction

Abstraction means hiding implementation details and showing only essential features. In C#, abstraction is achieved using abstract classes and interfaces.

Example

abstract class Vehicle
{
    public abstract void Start();
}

class Bike : Vehicle
{
    public override void Start()
    {
        Console.WriteLine("Bike starts with kick");
    }
}

The user only knows that the vehicle can start, not how it starts internally.

4. Inheritance

Inheritance allows one class to reuse the properties and methods of another class.

Example

class Animal
{
    public void Eat()
    {
        Console.WriteLine("Animal is eating");
    }
}

class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Dog is barking");
    }
}

Here, Dog inherits from Animal.

5. Polymorphism

Polymorphism means “many forms”. It allows the same method to behave differently.

Method Overriding Example

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing shape");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing circle");
    }
}

6. Interface

An interface is a contract that a class must follow.

interface IPrintable
{
    void Print();
}

class Document : IPrintable
{
    public void Print()
    {
        Console.WriteLine("Printing document");
    }
}

7. Access Modifiers

Access modifiers control the visibility of class members.

Modifier	Description
public	Accessible everywhere
private	Accessible only inside class
protected	Accessible in child classes
internal	Accessible within assembly

Real-Time Example (Bank System)

abstract class Bank
{
    public abstract void Interest();
}

class SBI : Bank
{
    public override void Interest()
    {
        Console.WriteLine("SBI Interest: 7%");
    }
}

Advantages of OOPS in C#

1. Code Reusability

2. Easy Maintenance

3. Security

4. Flexibility

5. Real-world Modeling

Conclusion

OOPS concepts form the backbone of C# programming. By understanding Encapsulation, Abstraction, Inheritance, and Polymorphism, beginners can easily move towards advanced topics like ASP.NET, Entity Framework, and Microservices.

Mastering OOPS will help you:

• Crack interviews

• Build clean architecture

• Write reusable code

• Understand enterprise-level applications

This knowledge is essential for every .NET developer starting their journey with C#.