C#设计模式怎样优化代码 - 问答

在C#中，设计模式可以帮助我们优化代码，提高代码的可维护性、可扩展性和可重用性。以下是一些常见的设计模式和如何优化代码的方法：

1. 单一职责原则（Single Responsibility Principle）

单一职责原则要求一个类只负责一项职责。这样可以降低类的复杂性，提高内聚性。

// 不符合单一职责原则
public class OrderProcessor
{
    public void ProcessOrder(Order order)
    {
        // 处理订单逻辑
        // ...

        // 发送订单确认邮件
        // ...
    }
}

// 符合单一职责原则
public class OrderProcessor
{
    private readonly EmailSender _emailSender;

    public OrderProcessor(EmailSender emailSender)
    {
        _emailSender = emailSender;
    }

    public void ProcessOrder(Order order)
    {
        // 处理订单逻辑
        // ...
    }

    public void SendOrderConfirmationEmail(Order order)
    {
        _emailSender.Send(order.Email, "Order Confirmation");
    }
}

2. 开闭原则（Open/Closed Principle）

开闭原则要求软件实体对扩展开放，对修改关闭。这意味着当需要添加新功能时，应该通过添加新代码来实现，而不是修改现有代码。

// 不符合开闭原则
public class PaymentGateway
{
    public void ProcessPayment(Payment payment)
    {
        if (payment.Method == "CreditCard")
        {
            // 处理信用卡支付
        }
        else if (payment.Method == "PayPal")
        {
            // 处理PayPal支付
        }
    }
}

// 符合开闭原则
public interface IPaymentGateway
{
    void ProcessPayment(Payment payment);
}

public class CreditCardGateway : IPaymentGateway
{
    public void ProcessPayment(Payment payment)
    {
        // 处理信用卡支付
    }
}

public class PayPalGateway : IPaymentGateway
{
    public void ProcessPayment(Payment payment)
    {
        // 处理PayPal支付
    }
}

3. 里氏替换原则（Liskov Substitution Principle）

里氏替换原则要求子类可以替换其父类而不影响程序的正确性。

// 不符合里氏替换原则
public class Bird
{
    public virtual void Fly()
    {
        // 飞行逻辑
    }
}

public class Penguin : Bird
{
    public override void Fly()
    {
        // 企鹅不能飞
    }
}

// 符合里氏替换原则
public abstract class Bird
{
    public abstract void Fly();
}

public class Penguin : Bird
{
    public override void Fly()
    {
        // 企鹅不能飞
    }
}

4. 依赖倒置原则（Dependency Inversion Principle）

依赖倒置原则要求高层模块不应该依赖于低层模块，两者都应该依赖于抽象。

// 不符合依赖倒置原则
public class Database
{
    public string GetData(string query)
    {
        // 从数据库获取数据
    }
}

public class UserRepository
{
    private readonly Database _database;

    public UserRepository(Database database)
    {
        _database = database;
    }

    public User GetUserById(int id)
    {
        return _database.GetData($"SELECT * FROM Users WHERE Id = {id}");
    }
}

// 符合依赖倒置原则
public interface IUserRepository
{
    User GetUserById(int id);
}

public class UserRepository : IUserRepository
{
    private readonly Database _database;

    public UserRepository(Database database)
    {
        _database = database;
    }

    public User GetUserById(int id)
    {
        return _database.GetData($"SELECT * FROM Users WHERE Id = {id}");
    }
}

5. 装饰器模式（Decorator Pattern）

装饰器模式允许动态地给对象添加新的功能，而不需要修改现有代码。

// 不使用装饰器模式
public class Coffee
{
    public string GetDescription()
    {
        return "Coffee";
    }

    public double GetCost()
    {
        return 1.99;
    }
}

// 使用装饰器模式
public interface ICoffee
{
    string GetDescription();
    double GetCost();
}

public class Coffee : ICoffee
{
    public string GetDescription()
    {
        return "Coffee";
    }

    public double GetCost()
    {
        return 1.99;
    }
}

public class Milk : ICoffee
{
    private readonly ICoffee _coffee;

    public Milk(ICoffee coffee)
    {
        _coffee = coffee;
    }

    public string GetDescription()
    {
        return $"{_coffee.GetDescription()}, Milk";
    }

    public double GetCost()
    {
        return _coffee.GetCost() + 0.49;
    }
}

通过使用这些设计模式，可以有效地优化C#代码，提高代码的质量和可维护性。

0 赞

0 踩