Code Smell - Large Classes
Generally, a class that is too large signals that it's doing too many things. The more responsibilities your class has, the more often you need to change it and any other code that references that class. This makes changes more complex and time-consuming and can introduce unrelated bugs.
SOLID principles are an excellent guideline for building software that is easy to maintain and extend. In particular, the 'S' in SOLID is the 'Single-responsibility Principle' and aims to reduce dependencies. If a bug is introduced with your change, it shouldn't affect other unrelated areas.
Those who don't follow it tend to create bloated classes containing thousands of lines of code, making it difficult to maintain. On the other hand, those who strictly stick to it creates too many small classes, making it hard to keep track of and maintain.
Here's an example of a large class that is doing too many things:
public class Car
{
private string make;
private string model;
private int year;
private string color;
private bool isRunning;
private bool isParked;
public Car(string make, string model, int year, string color)
{
this.make = make;
this.model = model;
this.year = year;
this.color = color;
this.isRunning = false;
this.isParked = true;
}
public void Start()
{
if (isParked)
{
isRunning = true;
isParked = false;
Console.WriteLine("The car has started.");
}
else
{
Console.WriteLine("You can't start the car while it's already running or not parked.");
}
}
public void Stop()
{
if (isRunning)
{
isRunning = false;
isParked = true;
Console.WriteLine("The car has stopped.");
}
else
{
Console.WriteLine("You can't stop the car while it's not running or already parked.");
}
}
public void Accelerate(int speed)
{
if (isRunning && !isParked)
{
Console.WriteLine($"The car is accelerating to {speed} mph.");
}
else
{
Console.WriteLine("You can't accelerate while the car is not running or parked.");
}
}
public void Brake()
{
if (isRunning && !isParked)
{
Console.WriteLine("The car is braking.");
}
else
{
Console.WriteLine("You can't brake while the car is not running or parked.");
}
}
public void Paint(string newColor)
{
color = newColor;
Console.WriteLine($"The car has been painted {newColor}.");
}
public void TuneUp()
{
Console.WriteLine("The car has had a tune-up.");
}
public void RepairEngine()
{
Console.WriteLine("The engine has been repaired.");
}
public void ReplaceTires()
{
Console.WriteLine("The tires have been replaced.");
}
// ...many more methods for various car-related tasks
}
This class represents a car and has many methods for performing tasks related to driving, maintenance, and repairs. However, it is trying to do too many things and violates the Single Responsibility Principle (SRP).
A better approach would be to break this class down into smaller, more focused classes that each have a single responsibility. For example:
public class Car
{
private string make;
private string model;
private int year;
private string color;
private Engine engine;
private Transmission transmission;
private Brakes brakes;
private Suspension suspension;
public Car(string make, string model, int year, string color)
{
this.make = make;
this.model = model;
this.year = year;
this.color = color;
this.engine = new Engine();
this.transmission = new Transmission();
this.brakes = new Brakes();
this.suspension = new Suspension();
}
public void Paint(string newColor)
{
color = newColor;
Console.WriteLine($"The car has been painted {newColor}.");
}
// ...other methods related to the car's appearance or overall state
public void PerformMaintenance()
{
engine.TuneUp();
transmission.ChangeFluid();
brakes.ReplacePads();
suspension.ReplaceShocks();
}
// ...other methods related to car maintenance or repairs
}