Title: Understanding Object-Oriented Programming in C#

Introduction:

Object-Oriented Programming (OOP) is a programming paradigm that has become a cornerstone in

modern software development. C# (C-sharp), a powerful and versatile programming language developed
by Microsoft, fully embraces the principles of OOP. In this article, we'll explore the key concepts of
Object-Oriented Programming in C# and understand how they contribute to building robust and
maintainable software.

1. **Classes and Objects:**

At the heart of OOP in C# are classes and objects. A class is a blueprint for creating objects, and an
object is an instance of a class. Classes encapsulate data and behavior, providing a way to structure and
organize code. Let's look at a simple example:

```csharp
class Car
{
public string Model;
public int Year;

public void StartEngine()

{
Console.WriteLine("Engine started!");
}
}

// Creating an object of the Car class

Car myCar = new Car();
myCar.Model = "Toyota";
myCar.Year = 2022;
 myCar.StartEngine();
```

2. **Encapsulation:**

Encapsulation is the concept of bundling data and methods that operate on that data within a single unit,
i.e., a class. Access modifiers such as `public`, `private`, and `protected` control the visibility of members.
This ensures that the internal details of a class are hidden from the outside world, promoting a more
secure and modular codebase.

```csharp
class BankAccount
{
private decimal balance;

public void Deposit(decimal amount)

{
balance += amount;
}

public void Withdraw(decimal amount)

{
if (amount <= balance)
balance -= amount;
else
Console.WriteLine("Insufficient funds");
}
}
```

3. **Inheritance:**
 Inheritance allows a class to inherit properties and methods from another class, fostering code reuse.
The base class (parent) provides a foundation, and the derived class (child) extends or modifies its
behavior.

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

class Dog : Animal

{
public void Bark()
{
Console.WriteLine("Woof!");
}
}

Dog myDog = new Dog();

myDog.Eat();
myDog.Bark();
```

4. **Polymorphism:**

Polymorphism allows objects of different types to be treated as objects of a common type. In C#, this is
achieved through method overloading and interface implementation.
```csharp
interface Shape
{
void Draw();
}

class Circle : Shape

{
public void Draw()
{
Console.WriteLine("Drawing a circle");
}
}

class Square : Shape

{
public void Draw()
{
Console.WriteLine("Drawing a square");
}
}

// Polymorphic behavior
Shape myShape = new Circle();
myShape.Draw();

myShape = new Square();

myShape.Draw();
```
5. **Abstraction:**

Abstraction involves simplifying complex systems by modeling classes based on essential properties
and behaviors. Abstract classes and interfaces in C# help achieve abstraction.

```csharp
abstract class Shape
{
public abstract void Draw();
}

class Circle : Shape

{
public override void Draw()
{
Console.WriteLine("Drawing a circle");
}
}
```

Conclusion:

Object-Oriented Programming in C# is a powerful paradigm that enhances code organization, reusability,

and maintainability. By understanding and applying concepts like classes, encapsulation, inheritance,
polymorphism, and abstraction, developers can create scalable and efficient software solutions.
Embracing these principles contributes to building modular and extensible applications in the ever-
evolving landscape of software development.