**Course Title:** Software Design Principles: Foundations and Best Practices **Section Title:** SOLID Principles **Topic:** Refactor a sample codebase to adhere to SOLID principles (Lab topic) **Objective:** In this lab, we will apply the SOLID principles to a sample codebase, learning how to identify violations of these principles and refactor the code to make it more maintainable, flexible, and scalable. **Prerequisites:** - Familiarity with object-oriented programming (OOP) concepts - Understanding of the SOLID principles (SRP, OCP, LSP, ISP, and DIP) - Basic knowledge of a programming language (preferably C#, Java, or C++) **Sample Codebase:** Let's consider a simple e-commerce system written in C#: ```csharp // Product.cs public class Product { public string Name { get; set; } public decimal Price { get; set; } public void SaveToDatabase() { // database logic to save product Console.WriteLine("Product saved to database"); } public void PrintProductInfo() { Console.WriteLine($"Name: {Name}, Price: {Price}"); } } ``` ```csharp // Order.cs public class Order { public List<Product> Products { get; set; } public Order() { Products = new List<Product>(); } public void AddProduct(Product product) { Products.Add(product); product.SaveToDatabase(); } public void CalculateOrderTotal() { decimal total = 0; foreach (var product in Products) { total += product.Price; } Console.WriteLine($"Order Total: {total}"); } } ``` **Refactoring the Codebase:** 1. **Single Responsibility Principle (SRP):** The `Product` class is responsible for both data storage and business logic. We will refactor it to separate these concerns: ```csharp // Product.cs public class Product { public string Name { get; set; } public decimal Price { get; set; } } // ProductRepository.cs public class ProductRepository { public void SaveToDatabase(Product product) { // database logic to save product Console.WriteLine("Product saved to database"); } } ``` 2. **Open/Closed Principle (OCP):** The `Order` class is responsible for calculating the order total. However, if we want to add tax or discount calculations, we would have to modify the `Order` class. We will refactor it to use an interface for calculations: ```csharp // IOrderCalculator.cs public interface IOrderCalculator { decimal CalculateOrderTotal(Order order); } // OrderTotalCalculator.cs public class OrderTotalCalculator : IOrderCalculator { public decimal CalculateOrderTotal(Order order) { decimal total = 0; foreach (var product in order.Products) { total += product.Price; } return total; } } // Order.cs public class Order { public List<Product> Products { get; set; } private readonly IOrderCalculator _calculator; public Order(IOrderCalculator calculator) { Products = new List<Product>(); _calculator = calculator; } public void AddProduct(Product product) { Products.Add(product); var repository = new ProductRepository(); repository.SaveToDatabase(product); } public decimal CalculateOrderTotal() { return _calculator.CalculateOrderTotal(this); } } ``` 3. **Liskov Substitution Principle (LSP):** Not applicable in this scenario. 4. **Interface Segregation Principle (ISP):** The `Order` class uses the `IOrderCalculator` interface for calculating the order total. However, if we want to add other calculations, we would have to modify the `IOrderCalculator` interface. We will refactor it to use separate interfaces for different calculations: ```csharp // IOrderTotalCalculator.cs public interface IOrderTotalCalculator { decimal CalculateOrderTotal(Order order); } // ITaxCalculator.cs public interface ITaxCalculator { decimal CalculateTax(Order order); } // OrderTotalCalculator.cs public class OrderTotalCalculator : IOrderTotalCalculator { public decimal CalculateOrderTotal(Order order) { decimal total = 0; foreach (var product in order.Products) { total += product.Price; } return total; } } // TaxCalculator.cs public class TaxCalculator : ITaxCalculator { public decimal CalculateTax(Order order) { // tax calculation logic decimal tax = 0; return tax; } } ``` 5. **Dependency Inversion Principle (DIP):** The `Order` class depends on a specific `ProductRepository` class for saving products. We will refactor it to use an interface for the `ProductRepository` class: ```csharp // IProductRepository.cs public interface IProductRepository { void SaveToDatabase(Product product); } // ProductRepository.cs public class ProductRepository : IProductRepository { public void SaveToDatabase(Product product) { // database logic to save product Console.WriteLine("Product saved to database"); } } // Order.cs public class Order { public List<Product> Products { get; set; } private readonly IProductRepository _repository; private readonly IOrderCalculator _calculator; public Order(IProductRepository repository, IOrderCalculator calculator) { Products = new List<Product>(); _repository = repository; _calculator = calculator; } public void AddProduct(Product product) { Products.Add(product); _repository.SaveToDatabase(product); } public decimal CalculateOrderTotal() { return _calculator.CalculateOrderTotal(this); } } ``` **Conclusion:** In this lab, we applied the SOLID principles to a sample codebase, refactoring it to make it more maintainable, flexible, and scalable. By following the SOLID principles, we can ensure that our codebase is designed to withstand the challenges of software development and maintenance. **External Resources:** - [SOLID principles by Uncle Bob](https://www.youtube.com/watch?v=QTBm3vZpZU4&ab_channel=ConfidentCoder) - [Dependency Inversion Principle by Pluralsight](https://www.pluralsight.com/courses/dependency-inversion-principle) **Note:** Please try to refactor your own codebase to adhere to the SOLID principles. You can use this lab as a guide to identify potential design issues and improve the maintainability of your code. **Leave a comment or ask for help:** If you have any questions or concerns about this lab, feel free to leave a comment below.