Object-Oriented Programming is a programming paradigm based on the concept of “objects” that contain data and behavior. In OOP, software is designed by creating classes which act as blueprints for objects. Objects encapsulate state (data) and operations (methods) that manipulate that state.

OOP promotes concepts like encapsulation, inheritance, polymorphism, and abstraction to build modular and reusable code.

• Encapsulation: Bundling data and methods that operate on that data within one unit (class), restricting direct access to some of the object's components.
• Inheritance: Mechanism where one class inherits members (properties, methods) from another class to promote code reuse and hierarchical classification.
• Polymorphism: Ability of objects to take many forms, mainly achieved by method overriding and method overloading.
• Abstraction: Hiding complex implementation details and showing only the necessary features to the user.

A class in C# is a blueprint or template for creating objects. It defines fields (data members), properties, methods, and events.

An object is an instance of a class. When a class is instantiated using the new keyword, an object is created in memory with its own copy of the class members.

class Car
{
    public string Make;
    public void Drive()
    {
        Console.WriteLine("Driving...");
    }
}

Car myCar = new Car();
myCar.Make = "Toyota";
myCar.Drive();

Encapsulation is the concept of restricting direct access to an object's data and only allowing it through well-defined interfaces (methods/properties). This hides the internal state and protects object integrity.

In C#, encapsulation is implemented using access modifiers like private, protected, internal, and public. Typically, fields are declared private and accessed via public properties or methods.

class Account
{
    private decimal balance;

    public decimal Balance
    {
        get { return balance; }
        private set { balance = value; } // private setter
    }

    public void Deposit(decimal amount)
    {
        if (amount > 0)
            Balance += amount;
    }
}

Inheritance allows a new class (derived class) to inherit members from an existing class (base class), promoting code reuse and logical hierarchy.

Example:

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

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

Dog dog = new Dog();
dog.Eat();  // Inherited from Animal
dog.Bark(); // Defined in Dog

C# supports:

• Single inheritance: A class inherits from one base class.
• Multilevel inheritance: A class inherits from a derived class.
• Hierarchical inheritance: Multiple classes inherit from a single base class.
• Multiple inheritance: Not supported for classes in C#, but multiple interfaces can be implemented by a single class.

Polymorphism means "many forms." It allows objects to be treated as instances of their base class but to behave differently depending on their actual derived class.

• Compile-time polymorphism (Method Overloading): Same method name with different parameters within the same class. Resolved by the compiler.
• Run-time polymorphism (Method Overriding): Derived class provides a specific implementation of a method declared in the base class using virtual and override. Resolved at runtime.

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

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

Shape s = new Circle();
s.Draw();  // Calls Circle.Draw()

Abstraction means hiding the complex implementation details and showing only essential features. It simplifies usage and reduces complexity.

In C#, abstraction can be achieved via abstract classes and interfaces:

• Abstract Class: Cannot be instantiated directly and can contain both abstract (without body) and concrete methods.
• Interface: Only declares method signatures (until C# 8.0), which implementing classes must define.

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

class Car : Vehicle
{
    public override void Start()
    {
        Console.WriteLine("Car started");
    }
}

A constructor is a special method invoked automatically when an object is created. It initializes the object state.

A destructor is a method called when an object is destroyed or garbage collected, used to release unmanaged resources.

class Person
{
    public string Name;

    public Person(string name)  // Constructor
    {
        Name = name;
    }

    ~Person()  // Destructor
    {
        Console.WriteLine("Destructor called");
    }
}

• Method Overloading: Multiple methods in the same class share the same name but differ in parameters (type, number, or order). It is a compile-time polymorphism feature.
• Method Overriding: A derived class provides a new implementation of a method declared virtual in the base class. It is a runtime polymorphism feature.

class Calculator
{
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b; // Overloading
}

class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}

class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Dog barks");
    }
}

A sealed class cannot be inherited by other classes. This is useful to prevent further inheritance when necessary.

A sealed method prevents further overriding of an inherited virtual method in subclasses.

sealed class FinalClass
{
    // Cannot be inherited
}

class Base
{
    public virtual void Display() { Console.WriteLine("Base Display"); }
}

class Derived : Base
{
    public sealed override void Display() { Console.WriteLine("Derived Display"); }
}

class FurtherDerived : Derived
{
    // Cannot override Display() here because it is sealed in Derived
}

Properties provide a flexible mechanism to read, write or compute private fields. They use get and set accessors to control access to fields, supporting encapsulation.

class Person
{
    private string name;

    public string Name
    {
        get { return name; }
        set 
        {
            if (!string.IsNullOrEmpty(value))
                name = value;
        }
    }
}

Interfaces define contracts that classes or structs must follow. They declare methods, properties, events, or indexers without implementation (until C# 8.0). Implementing interfaces enables polymorphism and decouples the code by defining behavior without specifying implementation.

interface ILogger
{
    void Log(string message);
}

class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

• is operator: Checks if an object is compatible with a given type and returns a Boolean.
• as operator: Attempts to cast an object to a specified type and returns null if the cast fails (does not throw exception).

object obj = "Hello";

if (obj is string)
{
    Console.WriteLine("obj is a string");
}

string s = obj as string;
if (s != null)
{
    Console.WriteLine("obj was cast successfully");
}

A namespace is a container for classes and other types, used to organize code and prevent name conflicts. It provides a way to logically group related classes.

namespace MyApplication.Models
{
    class User { }
}

namespace MyApplication.Services
{
    class UserService { }
}

• Method Overriding: Replaces the base class method with a new implementation using override. The base method must be virtual, abstract or override.
• Method Hiding: Uses the new keyword to hide the base class method without overriding it. Calls to the method depend on the reference type.

class Base
{
    public virtual void Show() { Console.WriteLine("Base Show"); }
}

class Derived : Base
{
    public new void Show() { Console.WriteLine("Derived Show"); }
}

Base b = new Derived();
b.Show();  // Calls Base.Show() because of method hiding