狠狠色丁香婷婷综合尤物/久久精品综合一区二区三区/中国有色金属学报/国产日韩欧美在线观看 - 国产一区二区三区四区五区tv

SOLID 原則是一套指南，可以幫助開發人員創建更易于維護、易于理解和靈活的軟件。這些原則是由 Robert C. Martin（Uncle Bob）提出的，并在面向對象編程社區中被廣泛采用。在本文中，我們將探討每個 SOLID 原則，并了解如何在 C# 中應用它們。

1. Single Responsibility Principle (SRP)

定義：一個類應該只有一個改變的原因，這意味著它應該只有一個工作或職責。

說明：SRP 旨在通過確保每個類處理單個功能來解耦代碼。這使得代碼更易于理解、測試和維護。

public class Invoice  
{  
    public void GenerateInvoice()  
    {  
        // Code to generate invoice  
    }  
  
    public void PrintInvoice()  
    {  
        // Code to print invoice  
    }  
}

在這里，該類有兩個職責：生成和打印發票。為了遵守 SRP，我們應該將這些職責分開：Invoice

public class InvoiceGenerator  
{  
    public void GenerateInvoice()  
    {  
        // Code to generate invoice  
    }  
}  
  
public class InvoicePrinter  
{  
    public void PrintInvoice()  
    {  
        // Code to print invoice  
    }  
}

2. Open/Closed Principle (OCP)

定義：軟件實體（類、模塊、函數等）應該開放以供擴展，但要關閉以供修改。

說明：OCP 鼓勵以一種允許在不修改現有代碼的情況下擴展行為的方式進行軟件設計。這可以通過抽象來實現，例如接口和抽象類。

示例：

public class Rectangle  
{  
    public double Width { get; set; }  
    public double Height { get; set; }  
  
    public double Area()  
    {  
        return Width * Height;  
    }  
}  
  
public class Circle  
{  
    public double Radius { get; set; }  
  
    public double Area()  
    {  
        return Math.PI * Radius * Radius;  
    }  
}

為了遵守 OCP，我們可以引入一個接口：

public interface IShape  
{  
    double Area();  
}  
  
public class Rectangle : IShape  
{  
    public double Width { get; set; }  
    public double Height { get; set; }  
  
    public double Area()  
    {  
        return Width * Height;  
    }  
}  
  
public class Circle : IShape  
{  
    public double Radius { get; set; }  
  
    public double Area()  
    {  
        return Math.PI * Radius * Radius;  
    }  
}

現在，可以在不修改現有 or 類的情況下添加新形狀。RectangleCircle

3. Liskov Substitution Principle (LSP)

定義：子類型必須可以替換其基本類型，而不改變程序的正確性。

說明：LSP 確保派生類在不更改其行為的情況下擴展基類。此原則對于維護可靠的繼承層次結構至關重要。

示例：

public class Bird  
{  
    public virtual void Fly()  
    {  
        // Fly  
    }  
}  
  
public class Penguin : Bird  
{  
    public override void Fly()  
    {  
        throw new NotSupportedException("Penguins can't fly.");  
    }  
}

在此示例中，違反了 LSP，因為它無法飛行。更好的方法是創建一個單獨的層次結構：Penguin

public abstract class Bird  
{  
    public abstract void Move();  
}  
  
public class FlyingBird : Bird  
{  
    public override void Move()  
    {  
        // Fly  
    }  
}  
  
public class NonFlyingBird : Bird  
{  
    public override void Move()  
    {  
        // Walk  
    }  
}

4. Interface Segregation Principle (ISP)

定義：不應強迫客戶端依賴于他們不使用的接口。

說明：ISP 主張創建小型的特定接口，而不是大型的通用接口。這樣可以防止實現類被它們不需要的方法所累。

public interface IWorker  
{  
    void Work();  
    void Eat();  
}  
  
public class Worker : IWorker  
{  
    public void Work()  
    {  
        // Work  
    }  
  
    public void Eat()  
    {  
        // Eat  
    }  
}  
  
public class Robot : IWorker  
{  
    public void Work()  
    {  
        // Work  
    }  
  
    public void Eat()  
    {  
        throw new NotImplementedException();  
    }  
}

在此示例中，不需要該方法。我們可以通過拆分接口來遵守 ISP：RobotEat

public interface IWorkable  
{  
    void Work();  
}  
  
public interface IFeedable  
{  
    void Eat();  
}  
  
public class Worker : IWorkable, IFeedable  
{  
    public void Work()  
    {  
        // Work  
    }  
  
    public void Eat()  
    {  
        // Eat  
    }  
}  
  
public class Robot : IWorkable  
{  
    public void Work()  
    {  
        // Work  
    }  
}

5. Dependency Inversion Principle (DIP)

定義：高級模塊不應依賴于低級模塊。兩者都應該依賴于抽象。抽象不應該依賴于細節。細節應該取決于抽象。

說明：DIP旨在通過使用抽象（接口或抽象類）來解耦依賴關系，從而減少高級模塊和低級模塊之間的耦合。

示例：

public class Light  
{  
    public void TurnOn()  
    {  
        // Turn on the light  
    }  
  
    public void TurnOff()  
    {  
        // Turn off the light  
    }  
}  
  
public class Switch  
{  
    private readonly Light _light;  
  
    public Switch(Light light)  
    {  
        _light = light;  
    }  
  
    public void Operate()  
    {  
        _light.TurnOn();  
    }  
}

為了遵守 DIP，我們可以引入一個接口：Light

public interface ISwitchable  
{  
    void TurnOn();  
    void TurnOff();  
}  
  
public class Light : ISwitchable  
{  
    public void TurnOn()  
    {  
        // Turn on the light  
    }  
  
    public void TurnOff()  
    {  
        // Turn off the light  
    }  
}  
  
public class Switch  
{  
    private readonly ISwitchable _switchable;  
  
    public Switch(ISwitchable switchable)  
    {  
        _switchable = switchable;  
    }  
  
    public void Operate()  
    {  
        _switchable.TurnOn();  
    }  
}

現在，類依賴于抽象而不是具體類。SwitchISwitchableLight

SOLID 原則是設計健壯、可維護和可擴展的面向對象軟件的基本準則。通過在 C# 項目中遵循這些原則，可以創建更易于理解、擴展和維護的代碼。