軟件架構設計原則和示例介紹
常見的架構設計原則包括以下幾個方面：
1. 單一職責原則（Single Responsibility Principle，SRP）：一個模塊或者類只負責一項功能。
2. 開閉原則（Open-Closed Principle，OCP）：軟件實體應該對擴展開放，對修改關閉。
3. 里氏替換原則（Liskov Substitution Principle，LSP）：所有引用基類對象的代碼都能夠透明地使用其子類對象。
4. 接口隔離原則（Interface Segregation Principle，ISP）：客戶端不應該依賴于它不需要的接口，即一個類對另一個類的依賴應該建立在最小的接口上。
5. 依賴倒置原則（Dependency Inversion Principle，DIP）：高層模塊不應該依賴于低層模塊，二者應該依賴于抽象接口。同時，抽象不應該依賴于細節，細節應該依賴于抽象。
這些原則可以指導我們設計出更加可擴展、可維護、可測試、可復用的架構。
為了更加詳細的說明，以下是各個原則的示例代碼：
1、單一職責原則（SRP）
// 錯誤的示例
public class User {
public void requestBook(string bookName) {
// 做一些請求書籍的事情
// ...
// 做一些記錄用戶行為的事情
logUserAction("request a book");
}
private void logUserAction(string action) {
// 記錄用戶行為到日志中
// ...
}
}
// 正確的示例
public class User {
public void requestBook(string bookName) {
// 做一些請求書籍的事情
// ...
}
}
public class UserActionLogger {
public void logUserAction(string action) {
// 記錄用戶行為到日志中
// ...
}
}在錯誤的示例中，`User` 類不僅要負責請求書籍的事情，還要負責記錄用戶行為。這不僅讓代碼變得復雜，而且不符合單一職責原則。正確的示例分離了不同的職責，把記錄用戶行為的功能獨立成了一個新的類。
2、開閉原則（OCP）
// 錯誤的示例
public class UserManager {
public void addUser(User user) {
// 添加用戶到數據庫中
// ...
}
public void deleteUser(User user) {
// 從數據庫中刪除用戶
// ...
}
}
// 新需求：修改用戶信息
public class UserManager {
public void addUser(User user) {
// 添加用戶到數據庫中
// ...
}
public void deleteUser(User user) {
// 從數據庫中刪除用戶
// ...
}
// 新需求：修改用戶信息
public void updateUser(User user) {
// 修改用戶信息
// ...
}
}
// 正確的示例
public interface IUserManager {
void addUser(User user);
void deleteUser(User user);
}
public class UserManager : IUserManager {
public void addUser(User user) {
// 添加用戶到數據庫中
// ...
}
public void deleteUser(User user) {
// 從數據庫中刪除用戶
// ...
}
}
public class AdvancedUserManager : IUserManager {
public void addUser(User user) {
// 添加用戶到數據庫中
// ...
}
public void deleteUser(User user) {
// 從數據庫中刪除用戶
// ...
}
// 新需求：修改用戶信息
public void updateUser(User user) {
// 修改用戶信息
// ...
}
}在錯誤的示例中，當需要添加新的需求（比如修改用戶信息）時，我們需要修改 `UserManager` 類。這顯然不符合開閉原則。正確的示例使用了接口和不同的實現類分離不同的功能，這樣當我們需要添加新的需求時，只需要創建一個新的實現類即可。
3、里氏替換原則（LSP）
// 錯誤的示例
public class Animal {
public virtual void eat() {
Console.WriteLine("Animal eat");
}
}
public class Dog : Animal {
public override void eat() {
Console.WriteLine("Dog eat");
}
}
public class Cat : Animal {
public override void eat() {
Console.WriteLine("Cat eat");
}
}
public class AnimalFeeder {
public void feed(Animal animal) {
animal.eat();
}
}
static void Main(string[] args) {
AnimalFeeder animalFeeder = new AnimalFeeder();
animalFeeder.feed(new Dog());
animalFeeder.feed(new Cat());
}
// 輸出：
// Dog eat
// Cat eat
// 錯誤的示例，違反了 LSP
public class WildAnimal : Animal {
}
static void Main(string[] args) {
AnimalFeeder animalFeeder = new AnimalFeeder();
animalFeeder.feed(new Dog());
animalFeeder.feed(new WildAnimal()); // 報錯！
}在錯誤的示例中，我們定義了一個 `WildAnimal` 類繼承自 `Animal` 類，但是這個類并沒有重寫 `eat()` 方法，而是直接繼承了父類的實現。當我們嘗試用 `WildAnimal` 對象來調用 `AnimalFeeder` 的 `feed()` 方法時，會出現運行時異常，因為 `WildAnimal` 對象沒有正確處理 `eat()` 方法。
4、接口隔離原則（ISP）
// 錯誤的示例
public interface IAnimal {
void eat();
void fly();
}
public class Dog : IAnimal {
public void eat() {
Console.WriteLine("Dog eat");
}
public void fly() {
throw new NotImplementedException(); // 錯誤的設計，狗不能飛行
}
}
public class Bird : IAnimal {
public void eat() {
Console.WriteLine("Bird eat");
}
public void fly() {
Console.WriteLine("Bird fly");
}
}
public class AnimalFeeder {
public void feed(IAnimal animal) {
animal.eat();
}
}
static void Main(string[] args) {
AnimalFeeder animalFeeder = new AnimalFeeder();
animalFeeder.feed(new Dog()); // 報錯！
animalFeeder.feed(new Bird());
}
// 正確的示例
public interface IEatable {
void eat();
}
public interface IFlyable {
void fly();
}
public class Dog : IEatable {
public void eat() {
Console.WriteLine("Dog eat");
}
}
public class Bird : IEatable, IFlyable {
public void eat() {
Console.WriteLine("Bird eat");
}
public void fly() {
Console.WriteLine("Bird fly");
}
}
public class AnimalFeeder {
public void feed(IEatable animal) {
animal.eat();
}
}
static void Main(string[] args) {
AnimalFeeder animalFeeder = new AnimalFeeder();
animalFeeder.feed(new Dog());
animalFeeder.feed(new Bird());
}在錯誤的示例中，我們定義了一個 `IAnimal` 接口，其中包含了 `eat()` 和 `fly()` 兩個方法。但是不是所有的動物都可以飛行，例如狗就不能飛行。正確的示例把 `IAnimal` 接口拆分成了 `IEatable` 和 `IFlyable` 兩個接口，這樣我們可以根據實際需要選擇使用哪個接口來表示一個動物的能力。
5、依賴倒置原則（DIP）
// 錯誤的示例
public class UserService {
private readonly UserDAO userDAO;
public UserService() {
this.userDAO = new UserDAO(); // 依賴了具體的實現
}
public void addUser(User user) {
userDAO.addUser(user);
}
}
public class UserDAO {
public void addUser(User user) {
// 添加用戶到數據庫中
// ...
}
}
// 正確的示例
public interface IUserDAO {
void addUser(User user);
}
public class UserDAO : IUserDAO {
public void addUser(User user) {
// 添加用戶到數據庫中
// ...
}
}
public class UserService {
private readonly IUserDAO userDAO;
public UserService(IUserDAO userDAO) {
this.userDAO = userDAO; // 依賴抽象接口
}
public void addUser(User user) {
userDAO.addUser(user);
}
}
static void Main(string[] args) {
IUserDAO userDAO = new UserDAO();
UserService userService = new UserService(userDAO);
userService.addUser(new User());
}在錯誤的示例中，`UserService` 類需要訪問數據庫添加用戶，但是直接依賴了 `UserDAO` 類。這使得 `UserService` 類不靈活，不能適應變化。正確的示例中，我們把 `UserDAO` 類抽象成了 `IUserDAO` 接口，并且通過構造函數注入了依賴。這樣做不僅遵循了依賴倒置原則，而且還能夠靈活地替換不同的實現類。
