---
# System prepended metadata

title: SOLID

---

# SOLID
- Mục tiêu: Đảm bảo khả năng bảo trì, mở rộng của việc phát triển ứng dụng
- Vì đây là vấn đề mindset nên Q cố gắng ko đưa code vào nên mọi người thông cảm. Q viết chủ yếu dựa trên hiểu biết bản thân và cũng cố gắng tuân theo (có khi không theo XD) nên cũng không cần qua gắt gao trong việc follow chuẩn SOLID nhé
## 1. Single Responsibility Principle
- Bất cứ thứ gì sinh ra trong code được gói trọn trong class, method, biến hay rộng hơn là module thì chỉ nên có 1 lí do tồn tại duy nhất. Hay nói dễ hiểu hơn là chỉ phụ trách một chức năng or mảng nghiệp vụ nào đó cụ thể
- Cực kì hạn chế các trường hợp như Tạo mới, Cập nhật, Xóa trong cùng 1 method mà không có sự phân tách rõ ràng giữa các action

- Bad
```csharp
public bool CreateOrUpdate(List<InputDataDto> data)
{
	// get create input dtos
 	// create new 
  // get update input dtos
  // update exist entities
  return true;
}
```
- Good
```csharp

public bool Create(List<CreateInputDto> data){
		// get create input dtos
 		// create new 
    return true;
}

public bool Update(List<UpdateInputDto> data){
  	// get update input dtos
  	// update exist entities
    return true
}
```

- Một chút ám ảnh cưỡng chế (ko khuyến khích bắt chước): Phân tách tất cả mọi thứ để đảm bảo khi bạn thay đổi thì chỉ có duy nhất 1 lí do thay đổi và 1 business duy nhất bị ảnh hưởng bởi sự thay đổi đó, đôi khi sẽ dẫn đến việc duplicate code
![](http://readme.idtek.com.vn/uploads/upload_27f6acf9d4d37355ed5424f479c6cf17.png =800x)

## 2. Open Closed Principle
- Method, class hay module trong vòng đời phát triển thì sẽ trải bao qua các lần thay đổi, sự thay đổi có thể đến từ nhiều yếu tố. Vì vậy, implementation phải đảm bảo cho sự thay đổi ko ảnh hưởng đến tính đúng đắn của chương trình, cũng như cho phép việc thay đổi là khả thi
- Ví dụ, class Polygon là 1 class abstract, logic SetPoints, GetPoints sẽ được đóng kín (closed) để đảm bảo tính đúng đắn, tuy nhiên method Area() để tính diện tích thì được định nghĩa dưới dạng abstract, cho phép các class kế thừa có thể override (open).
```csharp
public class Point
{
    public string Name { get; set; }
}

public abstract class Polygon
{
    private ICollection<Point> _points;

    public void SetPoints(ICollection<Point> points)
    {
        _points = points;
    }
    
    public ICollection<Point> GetPoints(){
        return _points;
    }
    public abstract double Area();
}

public class Rectangle : Polygon
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public override double Area()
    {
        return Width*Height;
    }
}
```

- Ví dụ: việc access data thông qua các ORM cũng tuân thủ Open closed principles, bạn sẽ có N cách để access, query data,... nhưng việc modification như create, update, delete sẽ rất hạn chế, cần nhiều validation trước khi thực thi
-> **Tăng cường khả năng mở rộng, Ràng buộc khả năng chỉnh sửa**
![](http://readme.idtek.com.vn/uploads/upload_87e8678c3a9af4bdffe1ad216ae17648.png =800x)

## 3. Liskov Substitution Principle
- Tính kế thừa trong OOP sẽ được đề cập đến với việc các child instance khi kế thừa parent instance thì **phải** làm đc những gì mà parent làm (thay thế parent), cũng như có thể làm thêm những thứ khác (nếu không làm thêm đc gì thì tại sao đẻ ra child instance)

![](http://readme.idtek.com.vn/uploads/upload_037367ad3b1e828afb82413cde674b42.png =800x)

- Ví dụ, class Child có thể thay thế Parent trong việc make coffee, ngoài ra còn có thể làm thêm milkshake
```csharp
public class Parent
{
    public void MakeCoffee()
    {
        Console.WriteLine("Coffee is done!");
    }
}

public class Child : Parent
{
    public void MakeMilkShake()
    {
        Console.WriteLine("Milkshake is done");
    }
}

public class Test
{
    public void GetBeverage()
    {
        var parent = new Parent();
        parent.MakeCoffee(); // <-- Parent can only make coffee

        var child = new Child(); // <-- Child can also make coffee and milkshake
        child.MakeCoffee(); 
        child.MakeMilkShake();
    }
}
```

## 4. Interface Segregation Principle
- Interface một khi định nghĩa và kế thừa thì các class implementation kế thừa chúng phải tuyệt đối implement cho tất cả các method mà được define trong interface
```csharp
public interface IWibuLife {
	void Eat();
  void Sleep();
  void AnimeTime();
}

public class DuyChuLife: IWibuLife{
	public void Eat(){
  	Console.WriteLine("Eat");
  }
  
  public void Sleep(){
  	Console.WriteLine("Sleep");
  }
  
  public void AnimeTime(){
  	// throw new NotImplementedException() // <-- Không đúng, nếu ko có AnimeTime() thì sao là wibu
    Console.WriteLine("Anime time !");
  }
}
```
- Hạn chế mấy vụ kế thừa interface xong throw NotImplementedException nhé 
![](http://readme.idtek.com.vn/uploads/upload_40773fe21626bbbce08ec7c5aaa998f3.png =800x)

## 5. Dependency Inversion Principle
- Thay vì phải tạo N con robot với N chức năng khác nhau thì chỉ cần 1 con robot duy nhất với N cánh tay robot theo từng loại chức năng. Để làm đc điều này, cẳng tay robot phải có 1 interface sao cho các cánh tay có thể dễ dàng tháo lắp.
- Vì vậy hãy luôn làm việc với lớp abstraction thay vì implementation. Giải thích một chút về abstraction và implementation
	- Abstraction: Dịch ra là trừu tượng hóa, theo từ điển tiếng việt trừu tượng có nghĩa "có được sự khái quát hoá trong tư duy, trên cơ sở dựa vào các thuộc tính, các quan hệ của sự vật; phân biệt với cụ thể" -> Làm việc với lớp abstraction nghĩa là Dev khi code, có sử dụng các class business nào đó để thực thi công việc thì chỉ gọi ra interface của class đó, vốn interface chỉ diễn đạt rằng class implement nó làm chức năng gì, nhận input gì và cho ra output gì.
  - Implementation: Dịch ra là sự thực hiện, sẽ là phần thực hiện cho abstraction kể trên. Trong class implementation này sẽ là phần thực thi tuân thủ tuyệt đối lớp abstraction
```diagram
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="421px" height="221px" viewBox="-0.5 -0.5 421 221" content="&lt;mxfile host=&quot;embed.diagrams.net&quot; modified=&quot;2022-06-09T03:05:27.439Z&quot; agent=&quot;5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36&quot; version=&quot;19.0.3&quot; etag=&quot;-IhUUBUWsXxF7-vnb8_N&quot; type=&quot;embed&quot;&gt;&lt;diagram id=&quot;5lR5zWMN_0i8njdrPlAo&quot; name=&quot;Page-1&quot;&gt;5Vddb5swFP01vE58hDQ8Qki3aZtUKZPWPjpwC9YMRsYkZL9+drDDh4lUtclWbRIPvsdf1+fcYwvLWxftR4aq/BtNgViunbaWF1uu6yxc15KfnR47ZOWuOiBjOFWDemCLf4ECbYU2OIV6NJBTSjiuxmBCyxISPsIQY/QwHvZMyXjXCmVgANsEERP9gVOe61Pc9fgnwFmud3aWQddTID1YnaTOUUoPA8jbWN6aUcq7VtGugUjyNC/dvPsLvefEGJT8JROUEHtEGnW2cFdzhhKOaalS5Ed9bkabMgU51bG86JBjDtsKJbL3IJQWWM4LorrVysA4tBezc85nFsUCtADOjmKInqBpUnXiLlV86Fl3fIXlA8YXCkNK6Oy8dM+FaCg65qnxDGo+FxWBQuSO3gU7XvAX2VkY7Bh8QJmG0mwiSgiqa5yMKej5skUELeaPqke2nyT+wVdR3A6GxUcdlCLrx2EwmCXDftop0vO6VCE1XD6hXhyHNiyBkVc4YhnwQY2YAg0EmONfYwyIqKT9OIk5UdQODxSL9C7qv/AnunbJq1nDS2Cy0GIxWcieLNQd2VjoVCPnY7+obHyjbGLYG5UjbsVKNpuChAmnTEgmnYLFDfwV7YA80BqfLOjFO8o5LQYDQoIz2cHpxHG04QSXsD6/CfaVLqnVmD3HNm3ozVTB8gouXN7Khb3znobGm3XhG9z0bqzjvdI6TuCPxQ9uZp07Q+sv1saxotCK7uW1lJ+iyAojZBSBqG4+ll088vSnMAOR7opLWoqR0TMmZAIhZadEaAlsxmcFTlO5zeyDNy6uK5jNnb55vmm25UzdTPV9jdlWhgDfNeeRk5wkwP8R88GfYz4wmN/qYo/lb4QO/DL7hwWwJwI4NxNAhP0vSHdV9T9y3uY3&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><rect x="0" y="160" width="150" height="40" rx="6" ry="6" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 148px; height: 1px; padding-top: 180px; margin-left: 1px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Abstraction</div></div></div></foreignObject><text x="75" y="184" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Abstraction</text></switch></g><rect x="270" y="160" width="150" height="40" rx="6" ry="6" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 148px; height: 1px; padding-top: 180px; margin-left: 271px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Implementation</div></div></div></foreignObject><text x="345" y="184" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Implementation</text></switch></g><path d="M 150 180 L 263.63 180" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 268.88 180 L 261.88 183.5 L 263.63 180 L 261.88 176.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/><ellipse cx="75" cy="7.5" rx="7.5" ry="7.5" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/><path d="M 75 15 L 75 40 M 75 20 L 60 20 M 75 20 L 90 20 M 75 40 L 60 60 M 75 40 L 90 60" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 67px; margin-left: 75px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: nowrap;">Dev</div></div></div></foreignObject><text x="75" y="79" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Dev</text></switch></g><path d="M 75 160 L 75 96.37" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 75 91.12 L 78.5 98.12 L 75 96.37 L 71.5 98.12 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/><rect x="170" y="150" width="60" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 165px; margin-left: 171px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Kế thừa</div></div></div></foreignObject><text x="200" y="169" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Kế thừa</text></switch></g><rect x="170" y="190" width="60" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 205px; margin-left: 171px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Thực thi</div></div></div></foreignObject><text x="200" y="209" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Thực thi</text></switch></g><rect x="80" y="110" width="60" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 125px; margin-left: 81px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Sử dụng</div></div></div></foreignObject><text x="110" y="129" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">Sử dụng</text></switch></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.diagrams.net/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>
```

- Một đoạn code quen thuộc
```csharp=
services.AddScoped<IBugFreeInterface, TwoHundredsImplementation>();
// thời gian fix bug như chó chạy, ta có thể có implementation mới vẫn đảm bảo tuân thủ interface
services.AddScoped<IBugFreeInterface, OneHundredImplementation>();
```
![](http://readme.idtek.com.vn/uploads/upload_f010af336a35b39eefd05bc8827149b8.png =800x)