DEV Community

SOLID Principles C# with real-time Example

Anil Singh on December 05, 2023

The SOLID principles, the rock stars of object-oriented design! Let's break them down: S - Single Responsibility Principle (SRP): A class should...
Read full post
Collapse
 
anilsingh profile image
Anil Singh •

Absolutely, let's go with a C# example:

1. Single Responsibility Principle (SRP):

// Not following SRP
public class Shape
{
public void Draw()
{
// Drawing logic
}

public double CalculateArea()
{
    // Area calculation logic
    return 0.0;
}
Enter fullscreen mode Exit fullscreen mode

}

// Following SRP
public class Shape
{
public void Draw()
{
// Drawing logic
}
}

public class Calculator
{
public double CalculateArea(Shape shape)
{
// Area calculation logic
return 0.0;
}
}

2. Open/Closed Principle (OCP):

// Not following OCP
public class Circle
{
public void Draw()
{
// Drawing logic
}

public double CalculateArea()
{
    // Area calculation logic
    return 0.0;
}

public double CalculateVolume()
{
    // Volume calculation logic, violating OCP
    return 0.0;
}
Enter fullscreen mode Exit fullscreen mode

}

// Following OCP
public abstract class Shape
{
public abstract void Draw();
public abstract double CalculateArea();
}

public class Circle : Shape
{
public override void Draw()
{
// Drawing logic
}

public override double CalculateArea()
{
    // Area calculation logic
    return 0.0;
}
Enter fullscreen mode Exit fullscreen mode

}

public class Cylinder : Shape
{
public override void Draw()
{
// Drawing logic
}

public override double CalculateArea()
{
    // Area calculation logic
    return 0.0;
}

public double CalculateVolume()
{
    // Volume calculation logic
    return 0.0;
}
Enter fullscreen mode Exit fullscreen mode

}

3. Liskov Substitution Principle (LSP):

// Not following LSP
public class Bird
{
public void Fly()
{
// Flying logic
}
}

public class Ostrich : Bird
{
public new void Fly()
{
throw new Exception("I can't fly!"); // Violates LSP
}
}

// Following LSP
public class Bird
{
public virtual void Move()
{
// Moving logic
}
}

public class Sparrow : Bird
{
public override void Move()
{
// Flying logic
}
}

public class Ostrich : Bird
{
public override void Move()
{
// Walking logic
}
}

*4. Interface Segregation Principle (ISP):
*
// Not following ISP
public interface IWorker
{
void Work();
void Eat();
}

public class Worker : IWorker
{
public void Work()
{
// Work logic
}

public void Eat()
{
    // Eat logic
}
Enter fullscreen mode Exit fullscreen mode

}

// Following ISP
public interface IWorkable
{
void Work();
}

public interface IEatable
{
void Eat();
}

public class Worker : IWorkable, IEatable
{
public void Work()
{
// Work logic
}

public void Eat()
{
    // Eat logic
}
Enter fullscreen mode Exit fullscreen mode

}

5. Dependency Inversion Principle (DIP):

// Not following DIP
public class LightBulb
{
public void TurnOn()
{
// Turn on logic
}

public void TurnOff()
{
    // Turn off logic
}
Enter fullscreen mode Exit fullscreen mode

}

public class Switch
{
public void Operate(LightBulb bulb)
{
if (bulb.State == "on")
{
bulb.TurnOff();
}
else
{
bulb.TurnOn();
}
}
}

// Following DIP
public interface ISwitchable
{
void TurnOn();
void TurnOff();
}

public class LightBulb : ISwitchable
{
public void TurnOn()
{
// Turn on logic
}

public void TurnOff()
{
    // Turn off logic
}
Enter fullscreen mode Exit fullscreen mode

}

public class Switch
{
public void Operate(ISwitchable device)
{
if (device.State == "on")
{
device.TurnOff();
}
else
{
device.TurnOn();
}
}
}

These C# examples should give you a practical understanding of how SOLID principles can be implemented in object-oriented programming.