Forem: Abhishek Adhav

Unlocking Azure Blob Storage: A Developer’s Journey, Comparisons & C# in Action

Abhishek Adhav — Mon, 06 Oct 2025 13:30:41 +0000

Many of us, when building apps and systems, don’t realize that where and how you store data is one of the most important decisions. It affects cost, performance, scale — and yes, profit. Whether you’re dealing with structured data (databases, rows & columns) or unstructured data (images, videos, logs, media files), there are tons of storage options — but some just work better than others depending on the situation.

In this post, we’re going to zoom in on Azure Blob Storage, a popular choice for storing unstructured data. Why? Because it scales really well, cost-friendly if used right, and it’s already being used in big stuff. For example:

OpenAI uses Azure Blob Storage (with scaled accounts) to handle massive datasets, checkpoints, and global replication — letting them focus on AI rather than managing storage.
DataCone (via Storware) backs up Exchange, OneDrive, SharePoint into Blob Storage — giving them scalable, secure archival and fast recovery.

So let’s get started

Concept

Azure Blob Storage is Microsoft's cloud-based object storage solution, designed to handle vast amounts of unstructured data. Unlike traditional file systems, Blob Storage allows you to store data such as text, images, videos, backups, and logs in a scalable and cost-effective manner.

🧱Core Components of Azure Blob Storage

Blob Storage is structured around three main components:

Storage Account: The top-level container that provides a unique namespace for your data. It serves as the entry point for accessing all your storage resources.
Container: Within a storage account, containers help organize blobs into a flat namespace, similar to directories in a file system.
Blob: The actual data object stored within a container. Blobs can be of various types, each optimized for specific use cases.

🌐Accessing Blob Storage

You can interact with Azure Blob Storage through various methods:

HTTP/HTTPS: Access blobs directly over the web.
Azure Storage REST API: Programmatically manage blobs using RESTful calls.
Azure CLI & PowerShell: Command-line tools for managing storage resources.
Azure SDKs: Client libraries available for languages like .NET, Java, Python, and Node.js.
SFTP & NFS: Secure file transfer and network file system protocols for accessing blobs.

In this we will learn how to interact using .NET

Comparision

📊In the cloud market, two popular storage services are Azure Blob Storage and Amazon S3. Let's compare their features to understand when to use each.

Feature	Azure Blob Storage	Amazon S3	Why It Matters
Storage Model	Object storage with containers (blobs)	Object storage with buckets	Both are object storage services, but Azure uses containers while AWS uses buckets. This distinction can influence how you organize and manage your data.
Storage Costs (per GB/month)	- Hot: $0.018 - Cool: $0.01 - Archive: $0.00135	- Standard: $0.023 - Intelligent-Tiering: $0.023 - One Zone-IA: $0.01 - Glacier: $0.004 - Glacier Deep Archive: $0.00099	Azure offers competitive pricing, especially for the Cool and Archive tiers. AWS provides a range of options, with Glacier Deep Archive being the most cost-effective for long-term storage.
Data Transfer Costs (per GB)	- Data In: Free - Data Out: $0.087	- Data In: Free - Data Out: $0.09	Both platforms offer free data ingress, but Azure's data egress costs are slightly lower, which can be beneficial for data-intensive applications.
Storage Tiers	Hot, Cool, Archive (account-level tiering)	Standard, Intelligent-Tiering, One Zone-IA, Glacier, Glacier Deep Archive (object-level tiering)	Azure applies storage tiers at the account level, meaning all blobs in a container share the same tier. AWS allows for more granular control, enabling different objects within a bucket to have different storage classes.
Performance & Scalability	High throughput with up to 20,000 IOPS per storage account; supports up to 500 requests per second per blob	High throughput with support for at least 3,500 PUT and 5,500 GET requests per second per prefix	Both services offer high scalability, but AWS's support for multiple prefixes can enhance performance in high-concurrency scenarios.
Data Replication	Locally Redundant Storage (LRS), Geo-Redundant Storage (GRS), Read-Access GRS (RA-GRS)	Standard, Intelligent-Tiering, One Zone-IA, Glacier, Glacier Deep Archive (object-level tiering)	Azure provides multiple replication options to ensure data durability and availability. AWS offers similar options but with different configurations and pricing structures.
Security & Compliance	Advanced threat protection, encryption at rest and in transit, compliance with global standards	Encryption at rest and in transit, access control policies, compliance with global standards	Both platforms offer robust security features, but Azure's integration with Microsoft security tools and services may provide additional benefits for organizations already using Microsoft's ecosystem.
Access Control	Azure Active Directory (AAD) integration, Shared Access Signatures (SAS)	Identity and Access Management (IAM), Bucket Policies, Access Control Lists (ACLs)	Azure's integration with AAD provides a unified identity management solution, which can simplify access control for organizations using Azure Active Directory.

Creation

1. Access the Azure Portal

Go to portal.azure.com

2. Create a Storage Account

In the left menu, select Storage accounts
Click Create

3. Configure Basic Settings

Subscription: Choose your active subscription
Resource Group: Select or create one
Storage Account Name: Use a unique name (3–24 lowercase letters/numbers)
Region: Pick your preferred Azure region
Performance: Choose Standard
Account Kind: Select StorageV2

4. Set Redundancy

Choose based on durability needs:

Option	Description
LRS	Replicates within one region
GRS	Replicates to a secondary region
RA-GRS	Adds read access to secondary region
ZRS	Replicates across availability zones
GZRS	Combines ZRS + GRS
RA-GZRS	Adds read access to GZRS

5. Configure Advanced Settings

Access Tier: Hot, Cool, or Archive
Secure Transfer Required: Enable
Hierarchical Namespace: Enable for Data Lake Gen2

6. Review and Create

Review all settings
Click Create to provision the storage account

Your Account is Created

🔐 Enable SFTP Access

Go to your Storage Account
Under Settings, select SFTP
Toggle Enable SFTP to Enabled
Click Save
Under SFTP settings, click Add user
Provide a username and assign permissions
Click Save to create the user

💸 SFTP Cost Analysis

Item	Cost Estimate
Hourly	$0.30/hour
Monthly	~$216 if enabled 24/7
Billing Note	Charges apply even without usage

Charges begin as soon as SFTP is enabled, regardless of whether data is transferred.
Costs can accumulate quickly if left running continuously.

✅ When to Use SFTP in Azure Blob Storage

SFTP (Secure File Transfer Protocol) is ideal when:

You need to integrate legacy systems that rely on SFTP for file exchange.
You want to migrate data securely from on-premises to Azure without rewriting existing tools.
You’re working with third-party vendors who require SFTP access for uploads/downloads.

⚠️ Best Practices to Optimize Cost

Enable SFTP only when actively needed
Disable SFTP when idle to avoid unnecessary charges
Monitor usage and billing regularly in the Azure Portal

Implementation

Let Understand it's integration with .net and how we can store the file

Access & Configuration Setup in .NET

Before writing blob code, you need to configure how your .NET application will access Azure Blob Storage—this includes credentials, app settings, and dependency injection.

🔐 a) Store Your Connection Info (or Use Identity)
You have a few options to authenticate your .NET app with Azure Blob Storage.

🔑 Connection String / Account Key
Store the connection string in appsettings.json, environment variables, or Azure App Service settings.

{
  "ConnectionStrings": {
    "AzureBlob": "DefaultEndpointsProtocol=https;AccountName=yourAccount;AccountKey=yourKey;EndpointSuffix=core.windows.net"
  }
}

🛡️ Managed Identity / Azure AD / TokenCredential
For better security, use Azure AD or Managed Identity (especially if hosted in Azure). This avoids storing secrets in config.

⚙️ Using Microsoft.Extensions.Azure Helpers
If you're using ASP.NET Core or a generic host, register BlobServiceClient via DI:

builder.Services.AddAzureClients(clientBuilder =>
{
    clientBuilder.AddBlobServiceClient(builder.Configuration.GetSection("Azure:Storage:Blob"));
});

Then inject BlobServiceClient wherever needed.

🧩 b) Wiring in Program.cs / Startup

In a typical ASP.NET Core app:

var builder = WebApplication.CreateBuilder(args);

// Bind configuration
builder.Services.AddControllers();

// Register Blob client via DI
builder.Services.AddAzureClients(clients =>
{
    clients.AddBlobServiceClient(builder.Configuration.GetSection("Azure:Storage:Blob"));
});

var app = builder.Build();
app.Run();


appsettings.json Example
{
  "Azure": {
    "Storage": {
      "Blob": {
        "ConnectionString": "DefaultEndpointsProtocol=https;AccountName=...;AccountKey=...;EndpointSuffix=core.windows.net"
      }
    }
  }
}

Injecting the Client
public class MyService
{
    private readonly BlobServiceClient _blobServiceClient;

    public MyService(BlobServiceClient blobServiceClient)
    {
        _blobServiceClient = blobServiceClient;
    }

    // ...
}

📦 Storage / Blob Operations in .NET
Once access is configured, here are common ways to store and manage blobs.

🧱 a) Basic Operations: Upload, Download, List, Delete

Using Azure.Storage.Blobs SDK (v12+):
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;

public async Task UploadFileAsync(string containerName, string localFilePath)
{
    BlobContainerClient container = _blobServiceClient.GetBlobContainerClient(containerName);
    await container.CreateIfNotExistsAsync(PublicAccessType.None);

    string fileName = Path.GetFileName(localFilePath);
    BlobClient blob = container.GetBlobClient(fileName);

    await blob.UploadAsync(localFilePath, overwrite: true);
}

public async Task DownloadFileAsync(string containerName, string blobName, string downloadPath)
{
    BlobContainerClient container = _blobServiceClient.GetBlobContainerClient(containerName);
    BlobClient blob = container.GetBlobClient(blobName);
    await blob.DownloadToAsync(downloadPath);
}

public async Task<List<string>> ListBlobsAsync(string containerName)
{
    BlobContainerClient container = _blobServiceClient.GetBlobContainerClient(containerName);
    var names = new List<string>();
    await foreach (BlobItem item in container.GetBlobsAsync())
    {
        names.Add(item.Name);
    }
    return names;
}

public async Task DeleteBlobAsync(string containerName, string blobName)
{
    BlobContainerClient container = _blobServiceClient.GetBlobContainerClient(containerName);
    BlobClient blob = container.GetBlobClient(blobName);
    await blob.DeleteIfExistsAsync();
}

🚀 Advanced Storage Patterns in Azure Blob Storage

Depending on your scenario, Azure Blob Storage offers multiple blob types and access strategies. Here's a breakdown:

🧱 Blob Types

Blob Type	Use Case
Block Blobs	Default type. Ideal for storing files, documents, images, and backups.
Append Blobs	Optimized for append-only operations like logging or telemetry data.
Page Blobs	Supports random read/write access. Used for virtual hard disks (VHDs) and VM disks.

🔐 Access Strategies

Strategy	Purpose
SAS Tokens	Generate scoped, time-limited access for clients without exposing account keys.
Streaming Uploads	Upload directly from memory, streams, or web requests—no need for local files.
Chunked Uploads	Upload large files in blocks for better performance and reliability.

🧰 Example Use Cases

Block Blob: Uploading user profile images or PDFs
Append Blob: Writing logs from a web app or IoT device
Page Blob: Hosting a VHD for an Azure VM
SAS Token: Sharing a file securely with a third party
Streaming Upload: Saving a file from an HTTP request directly to blob
Chunked Upload: Handling 5GB+ video files with retry logic

🧾 Final Thoughts

This is one way to integrate Azure Blob Storage in .NET. Depending on your app type (web, console, microservice), hosting environment (Azure App Service, AKS, VM), and security needs, you can adapt the approach.
There are many ways to do this—what matters is choosing the right one for your scenario.
Thanks for reading! 🙌
Let me know in the comments how you’re using Blob Storage in your projects or if you’d like a follow-up on performance tuning, SAS tokens, or Data Lake Gen2.

Let me know if you'd like help turning this into a downloadable guide or adding diagrams for architecture and flow. You're building a solid technical resource!

Ultimate Guide to OOP Interview Questions for C#

Abhishek Adhav — Fri, 19 Sep 2025 16:32:07 +0000

As you're aware, OOP (Object-Oriented Programming) is foundational in enterprise software development. Whether you're working in C#, Java, or C++, mastering OOP is essential—not just for writing maintainable code, but also for performing well in technical interviews. Below are some of the most commonly asked OOP interview questions, focused on C# but also applicable in simpler forms to Java and C++

1. Explain what are four pillar of OOPS?

Ans :- The four foundational principles—commonly referred to as the four pillars of Object-Oriented Programming

Encapsulation Encapsulation is the practice of bundling data (attributes) and the methods that operate on that data into a single class, while also restricting access to the internal representation.

As an SDE, you'll often use encapsulation to ensure that your objects expose only what they need to—through controlled interfaces (like getBalance() and deposit(amount)), while keeping the sensitive state (like balance) private and protected. This keeps the system modular, secure, and maintainable

class BankAccount {
  private double balance;

  public double getBalance() { return balance; }
  public void deposit(double amount) {
    if (amount > 0) balance += amount;
  }
}

Inheritance Inheritance allows a class (child) to derive properties and methods from another class (parent), enabling code reuse, logical hierarchy formation, and extensibility.

In enterprise systems, inheritance helps you create clean hierarchies (e.g., Vehicle → Car, Vehicle → Motorcycle) allowing you to define shared behavior once, then specialize as needed—minimizing duplication and enhancing maintainability

class Vehicle { 
  public void startEngine() { 
     Console.WriteLine("Vehicle Start");
  } 
}
class Car extends Vehicle {
  void openTrunk() {
     Console.WriteLine("Car Truck Open"); 
  }
}

Abstraction Abstraction focuses on presenting essential features while hiding unnecessary implementation details. It typically manifests via abstract classes or interfaces that define a contract but not the full implementation.

When designing systems—say, a Smart Home API with generic Device operations—it allows you to present a clean interface (turnOn(), turnOff()) across varied device types, with each device implementing the behavior. This enables clarity, flexibility, and extensibility

abstract class Device {
  abstract void turnOn();
  abstract void turnOff();
}
class Light extends Device { ... }
class Thermostat extends Device { ... }`

Polymorphism Polymorphism means “many forms.” It allows objects to be treated as instances of their parent class while invoking method implementations that are specific to the actual subtype. It can be compile-time (method overloading) or runtime (method overriding).

In practical scenarios, polymorphism makes your code flexible and generically extensible. For example, a collection of Shape objects can call draw() on each shape, and the correct behavior (circle drawing vs rectangle drawing) happens automatically

class Shape { void draw() { ... } }
class Circle extends Shape { @Override void draw() { ... } }
Shape s = new Circle();
s.draw(); // Executes Circle’s draw()

Why This Order Makes Sense for SDE Interviewers
Essentially, it means you start by protecting your data (encapsulation), then reuse and organize it with hierarchies (inheritance), hide the details behind clean interfaces (abstraction), and finally let your code adapt to different behaviors when needed (polymorphism).

2. Explain difference between abstraction and encapsulation ?

Ans :- Both are two different concept and has a diffrent purpose

Abstraction: Focuses on what a class does by hiding the underlying complexity and exposing only the necessary behavior.
Privatizing the inner workings and wrapping it in a public shell so details can change without impacting how it’s used.

Defines what an object should do, without revealing how it’s implemented:

public abstract class Shape
{
    public abstract double Area();
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}

Users call Area() without knowing the calculation details.

Encapsulation: Focuses on how a class protects its internal data by bundling it with methods and restricting direct access.Binding data and operations into a class, hiding the internals with access modifiers while exposing a controlled public interface.
Protects internal state and ensures controlled access:

public class BankAccount
{
    private decimal balance;

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

    public decimal GetBalance() => balance;
}

The balance field is private and can be changed only via validated methods.

3. Explain different type of Polymorphism?

Ans :- This question can be ask in different why like Explain compile time polymorphism (static) and run time(Dynamic) polymorphism. Here is the detail explanation of it .

Compile-Time Polymorphism (Static Polymorphism)

What it is: The method to call is determined at compile time.
How it's done: Typically via method overloading (same method name, different parameters) or operator overloading.

public class MathOps
{
    public int Add(int a, int b) => a + b;
    public float Add(float a, float b) => a + b;
}

Here, the correct Add method is selected by the compiler based on argument types.

Run-Time Polymorphism (Dynamic Polymorphism)

What it is: The method to call is determined at runtime, based on the object’s actual type.
How it's done: Through method overriding using virtual and override keywords with inheritance.

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

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

Animal pet = new Dog();
pet.Speak();  // Outputs: "Dog barks"

Here, the program decides at runtime to call Dog’s Speak() override.

4. Explain what access modifiers and its type?
Ans :- Access modifiers are special keywords in C# that determine who can see or use certain parts of your code—whether it's within the same class, the same assembly (project), or anywhere in the application. They play a key role in encapsulation, ensuring that only the right parts of your code are exposed or hidden.

public: Accessible from anywhere—across classes and assemblies.
private: Accessible only within the same class.
protected: Accessible within the same class and derived classes.
internal: Accessible only within the same assembly.

5. Explain difference between abstract class and interface?
Ans :-

Abstract Class

An abstract class is a class that cannot be instantiated on its own; it must be subclassed. It can have both abstract methods (methods without implementation) and normal methods (methods with implementation).

Abstract methods: These are methods that are declared but have no implementation. They are meant to be overridden by subclasses.

Normal methods: These are methods that have a complete implementation in the abstract class and can be used as is by the subclasses.

Key points about Abstract Class:

Can have both abstract and normal methods.

Can have member variables (fields) and constructors.

Can provide a partial implementation of methods, meaning some methods are implemented, but others are left abstract for subclasses to define.

A class can only inherit from one abstract class (single inheritance).

Example of an Abstract Class:

abstract class Animal {
    // Abstract method (no implementation)
    public abstract void makeSound();

    // Normal method (with implementation)
    public void sleep() {
        System.out.println("The animal is sleeping.");
    }
}

class Dog extends Animal {
    // Implementing the abstract method
    public void makeSound() {
        System.out.println("Bark!");
    }
}

Interface

An interface is a contract or blueprint that specifies what methods a class must implement, but it cannot provide any implementation itself (though some languages now allow default method implementations in interfaces). All methods in an interface are abstract by default.

No implementation in interface: The methods in an interface only declare what methods the implementing class should have, but they do not provide any functionality themselves.

Cannot have instance variables: Unlike an abstract class, an interface cannot have member variables (fields). It can only declare constants (static final fields).

Can be implemented by any class: A class can implement multiple interfaces (multiple inheritance), which is one key advantage over abstract classes.

Key points about Interface:

Only abstract methods (no method bodies unless it's a default method in some languages).

Cannot have constructors or instance variables.

Supports multiple inheritance (a class can implement multiple interfaces).

Used when you want to define a common set of methods for classes that might not share a common ancestor.

Example of an Interface:

interface Animal {
    void makeSound(); // Abstract method with no implementation
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark!");
    }
}

6.Explain virtual and override keyword?
Ans :-

virtual Keyword Used in the base class. Marks a method that can be overridden in derived classes. Allows a method to have a default implementation, but it can be changed in subclasses.
override Keyword: Used in the derived class. Replaces the implementation of a virtual method from the base class. Ensures the method in the derived class has a new implementation.

using System;
class Animal
{
    // Virtual method: can be overridden by derived classes
    public virtual void MakeSound()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

class Dog : Animal
{
    // Override the virtual method to provide specific implementation
    public override void MakeSound()
    {
        Console.WriteLine("Bark!");
    }
}

class Program
{
    static void Main()
    {
        Animal myDog = new Dog(); // Polymorphism: Animal reference, Dog object
        myDog.MakeSound(); // Output: Bark!
    }
}

7. What is the difference between method overloading and method overriding?
Ans:
Method Overloading
Occurs at compile time. You define multiple methods in the same class with the same name but different signatures (different number or types of parameters). Overloading is a way to provide multiple ways to call a method.
Example:

class Calculator {
    public int Add(int a, int b) { return a + b; }
    public double Add(double a, double b) { return a + b; }
    public int Add(int a, int b, int c) { return a + b + c; }
}

Method Overriding
Occurs at runtime (dynamic polymorphism). A derived class provides its specific implementation of a method that’s already defined in base class (which is marked virtual, abstract, or override in further parent). To override, you use the override keyword in the derived class.
Example:

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

8. What is the sealed keyword in C#, and when would you use it?
Ans:-
The sealed keyword can be used in two main contexts:

Sealing a class: If you mark a class as sealed, it cannot be inherited. No class can derive from that class.

public sealed class FinalClass {
  public void DoSomething() { … }
}
// public class Derived : FinalClass { } // Not allowed

Sealing an override method: In a derived class, if you override a virtual method, you can mark that override as sealed override. This prevents further derived classes from overriding that method again.

class Base {
  public virtual void Display() { … }
}
class Intermediate : Base {
  public sealed override void Display() { … }
}
class FurtherDerived : Intermediate {
  // public override void Display() { … }  // Not allowed
}

When to use sealed:

To prevent inheritance where it doesn’t make sense or might cause incorrect use.

To lock down behavior for security or consistency.

Sometimes for performance reasons (sealed classes are optimized better by compiler/JIT in some cases).

9. What are value types vs reference types in C#? Give examples.
Ans:
Value Types
Stored in the stack (or inline in containing objects)
When you assign one value-type variable to another, it copies the value (they are independent)
Examples: int, double, bool, struct, enum

Reference Types
Stored as references (the value is a reference/pointer) to data stored in the heap
When you assign one reference-type variable to another, both reference the same object. Changes via one variable reflect in the other.
Examples: class objects, string (though it's immutable), arrays, delegates
Why it matters: memory usage; behavior of assignment; garbage collection; performance implications (boxing / unboxing when converting between value/reference types).

10. What is a static class in C#? How is it different from a regular class?
Ans:-
A static class in C# is a class that:
Cannot be instantiated (you can’t create an object using new).
All its members (methods, properties, fields) must be static.
Is implicitly sealed. You cannot derive from a static class.
Differences vs regular class:

Regular class: you can create instances; can have both static and non-static members; subclasses possible.

Static class: only static members; no instances; no inheritance; often used for utility/helper functionality or grouping related static operations.
Example use case: Methods like Math.Sqrt(), or utility methods in a helper class that don’t need object state.

SOLID Principle

Abhishek Adhav — Sat, 28 Dec 2024 16:52:25 +0000

What are SOLID Principle

The SOLID principles are design principles aimed at creating more understandable, flexible, and maintainable software. These principles can help improve the design of the application and improving the structure of an software applications.
Following are the five SOLID principle.

Single Responsibility Principle (SRP)
Open/Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP) We will understand all of this in detail.

Single Responsibility Principle (SRP)
Definition :- Every class should have only one reason to change.

SRP suggest that one class should have only one responsibility means every class, module, or function in a program should have one responsibility/purpose in a program.

Above code snippet violate the SRP principle StudentRegistration have two responsibility.

We can fix this by separating the logic for RegisterStudent and Calculate_Student_Result in different class.

Merits of SRP:

Improved maintainability and easier testing due to focused, single-responsibility classes.

Demerits of SRP:

Can lead to over-engineering with an increased number of classes and added complexity for simple applications.

Open/Closed Principle (OCP)

Definition :- Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification

OCP in simple words say that once created class or function should be closed for further modification means once the class is correctly working no addition logic should be added to the class. But open for extension means one can extend the implementation (of a class or function) of logic and/or functionality by using Inheritance.

In the above example if we want to add another type of customer we will have to change the class DiscountCalculator. which violate the rule.
This can be resolve by introducing new Interface which will defines a CalculateDiscount method, which each customer class will implement.

Now in this scenario the DiscountCalculator class will never be modified but will be used for extension .

Merits of Open/Closed Principle:

Enhances flexibility by allowing extensions without modifying existing code, promoting maintainability.

Demerits of Open/Closed Principle:

Can lead to increased complexity and a larger number of classes due to the need for abstraction and extensions.

Liskov Substitution Principle (LSP)

Definition :- It states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

In other words, subtypes must be substitutable for their base types without altering the desirable properties of the program, such as correctness, behavior, or functionality.

In the above code the LSP principle is follow as the object of object of Shape can be replaceable by Square class and it not breaking the behavior of the program.

Merits of Liskov Substitution Principle (LSP):

Enhances code reusability and maintainability by ensuring subclasses can be substituted for base classes without altering the program’s correctness.

Demerits of Liskov Substitution Principle (LSP):

May lead to overly complex hierarchies if not applied carefully, potentially causing confusion or unnecessary abstraction.

Interface Segregation Principle (ISP)

Definition :- The Interface Segregation Principle (ISP) states that clients should not be forced to depend on interfaces they do not use.
In other words, rather than having a large, all-encompassing interface, it's better to break it down into smaller, more specific interfaces. This ensures that a class or client only needs to implement or depend on the methods that are relevant to them.

Both Engineer and Designer are forced to implement methods that may not be relevant to their job role. For example, a Designer might not need to implement Eat() or Sleep() methods in a real-world scenario, but the large interface forces them to do so.

The solution is to split the large IWorker interface into smaller, more specific interfaces, so each class only implements the methods it truly needs.

Merits of ISP:

Improves maintainability, flexibility, and testability by ensuring classes only depend on the methods they use.

Demerits of ISP:

Increases the number of interfaces to manage and may lead to unnecessary abstraction.

Dependency Inversion Principle (DIP)

Definition :- High-level modules should not depend on low-level modules. Both should depend on abstractions.

This principle encourages decoupling of high-level logic (business rules) from low-level details (implementation). Instead of the high-level module directly depending on the low-level module, both should depend on abstractions (like interfaces or abstract classes).

Below example show the tight couple of high level module with low-level module

The NotificationService is directly dependent on EmailService. If we want to change the email implementation (e.g., switch to SMS or push notification), we must modify the NotificationService class, violating the DIP.
Here is a solution

Now The NotificationService class depends on IMessageService, not on a specific low-level implementation like EmailService. It receives the IMessageService dependency via constructor injection.

Merits of DIP:

Improves flexibility, maintainability, and testability by decoupling high-level and low-level modules through abstractions.

Demerits of DIP:

Increases complexity due to the need for abstractions and dependency injection.

SO this are the five SOLID principle which is used for clean coding and can be followed in any programming language