Conociendo el principio de responsabilidad única

What is the single responsibility principle in SOLID?

The SOLID framework is fundamental to object-oriented programming and one of its cornerstones is the Single Responsibility Principle. This principle, known as the Single Responsibility Principle (SRP), states that each component within a system must have a single responsibility. This rule is crucial to ensure code cohesion and modularity, offering advantages such as increased maintainability and ease of testing.

How is this principle applied in C#?

When you implement the single responsibility principle in C# or any other language that supports object-oriented programming, each class or method must perform a specific task.

• Classes: A class must be bound to a single model and limited to a specific system responsibility.
• Methods: Each method must perform a single operation; their names must clearly reflect the action or task they perform.

System components under SRP?

The single responsibility principle applies not only to methods and classes, but extends to other system components:

• Modules: Each module must concentrate on performing a single function.
• Libraries: They must contain specific functionalities, without mixing them with other responsibilities.
• Microservices: In modern architectures, each microservice should handle a single responsibility or process.

Practical example: Analysis of a user story

Let's analyze the following requirement: as a user, after confirming a purchase, I expect to receive a confirmation message, to be able to download an invoice and to receive a confirmation email. At first glance, this user demands three simultaneous actions, which, from a programming point of view, does not imply that we should create a single class or method that covers all these functions.

• Purchase confirmation: Display a confirmation message and save the event in the database.
• Invoice download: Facilitate the download of the payment receipt.
• Confirmation email: Send an email as proof of the completed process.

Instead of creating a monolithic solution, we should separate these actions into different components or services, each with its own defined responsibility.

Case Study: Student Repository

In the course we will analyze a demo with a class called StudentRepository. This class does not currently comply with the single responsibility principle. This will be a practical exercise to identify its deficiencies and refactor the code to comply with the SRP, ensuring that each part of the system maintains a single specific task.

In conclusion, effective use of the Single Responsibility Principle not only improves code structure and maintainability, but also paves the way for future extensions, making them less error prone and easier to update. Keep learning and improving your programming skills!