聆途笔记

C#设计模式实践：提升代码质量的关键技术

设计模式是软件开发中经过验证的最佳实践解决方案，它们为解决常见问题提供了可重用的模板。在C#开发中，合理运用设计模式可以显著提高代码的可维护性、可扩展性和可重用性。本文将介绍几种在C#中常用的设计模式及其实际应用场景。

1. 单例模式(Singleton)

应用场景：当系统中只需要一个全局访问点的类实例时，如配置管理器、日志记录器或数据库连接池。

C#实现：

public sealed class AppConfig
{
    private static readonly Lazy<AppConfig> _instance = 
        new Lazy<AppConfig>(() => new AppConfig());

    public static AppConfig Instance => _instance.Value;

    public string ConnectionString { get; private set; }
    public int Timeout { get; private set; }

    private AppConfig()
    {
        // 初始化配置
        ConnectionString = ConfigurationManager.ConnectionStrings["Default"].ConnectionString;
        Timeout = int.Parse(ConfigurationManager.AppSettings["Timeout"]);
    }

    // 使用方法
    // var config = AppConfig.Instance;
}

线程安全考虑：使用Lazy确保线程安全且延迟初始化。

2. 工厂方法模式(Factory Method)

应用场景：当创建对象的逻辑变得复杂，或需要根据条件创建不同的对象时。

C#实现：

public interface IPaymentProcessor
{
    void ProcessPayment(decimal amount);
}

public class CreditCardProcessor : IPaymentProcessor
{
    public void ProcessPayment(decimal amount) => Console.WriteLine($"信用卡支付: {amount}");
}

public class PayPalProcessor : IPaymentProcessor
{
    public void ProcessPayment(decimal amount) => Console.WriteLine($"PayPal支付: {amount}");
}

public abstract class PaymentProcessorFactory
{
    public abstract IPaymentProcessor CreateProcessor();

    // 可添加一些默认实现
    public void ProcessOrder(Order order)
    {
        var processor = CreateProcessor();
        processor.ProcessPayment(order.TotalAmount);
    }
}

public class CreditCardProcessorFactory : PaymentProcessorFactory
{
    public override IPaymentProcessor CreateProcessor() => new CreditCardProcessor();
}

public class PayPalProcessorFactory : PaymentProcessorFactory
{
    public override IPaymentProcessor CreateProcessor() => new PayPalProcessor();
}

// 使用示例
var factory = new CreditCardProcessorFactory();
factory.ProcessOrder(order);

3. 观察者模式(Observer)

应用场景：当一个对象的状态变化需要通知其他多个对象时，如事件处理系统。

C#现代化实现（使用事件和委托）：

public class StockMarket
{
    public event EventHandler<StockChangedEventArgs> StockChanged;

    private decimal _price;
    public decimal Price
    {
        get => _price;
        set
        {
            if (_price != value)
            {
                _price = value;
                OnStockChanged(new StockChangedEventArgs(value));
            }
        }
    }

    protected virtual void OnStockChanged(StockChangedEventArgs e)
    {
        StockChanged?.Invoke(this, e);
    }
}

public class StockChangedEventArgs : EventArgs
{
    public decimal NewPrice { get; }

    public StockChangedEventArgs(decimal newPrice)
    {
        NewPrice = newPrice;
    }
}

// 订阅者
public class StockDisplay
{
    public StockDisplay(StockMarket market)
    {
        market.StockChanged += (sender, e) => 
            Console.WriteLine($"股价更新: {e.NewPrice}");
    }
}

// 使用示例
var market = new StockMarket();
var display = new StockDisplay(market);
market.Price = 120.5m; // 自动触发通知

4. 策略模式(Strategy)

应用场景：当需要在运行时选择算法或行为时。

C#实现：

public interface ISortingStrategy
{
    void Sort<T>(List<T> list) where T : IComparable<T>;
}

public class QuickSortStrategy : ISortingStrategy
{
    public void Sort<T>(List<T> list) where T : IComparable<T>
    {
        // 实现快速排序
        list.Sort();
        Console.WriteLine("使用快速排序");
    }
}

public class MergeSortStrategy : ISortingStrategy
{
    public void Sort<T>(List<T> list) where T : IComparable<T>
    {
        // 实现归并排序
        // 简化示例，实际应实现归并排序算法
        list = list.OrderBy(x => x).ToList();
        Console.WriteLine("使用归并排序");
    }
}

public class Sorter
{
    private ISortingStrategy _strategy;

    public Sorter(ISortingStrategy strategy)
    {
        _strategy = strategy;
    }

    public void SetStrategy(ISortingStrategy strategy)
    {
        _strategy = strategy;
    }

    public void Sort<T>(List<T> list) where T : IComparable<T>
    {
        _strategy.Sort(list);
    }
}

// 使用示例
var numbers = new List<int> { 5, 2, 8, 1, 9 };
var sorter = new Sorter(new QuickSortStrategy());
sorter.Sort(numbers);

sorter.SetStrategy(new MergeSortStrategy());
sorter.Sort(numbers);

5. 装饰器模式(Decorator)

应用场景：当需要动态地给对象添加额外的职责时。

C#实现：

public interface IDataProcessor
{
    string Process(string data);
}

public class BasicDataProcessor : IDataProcessor
{
    public string Process(string data) => data.ToUpper();
}

public abstract class DataProcessorDecorator : IDataProcessor
{
    protected IDataProcessor _processor;

    protected DataProcessorDecorator(IDataProcessor processor)
    {
        _processor = processor;
    }

    public virtual string Process(string data) => _processor.Process(data);
}

public class EncryptionDecorator : DataProcessorDecorator
{
    public EncryptionDecorator(IDataProcessor processor) : base(processor) {}

    public override string Process(string data)
    {
        string processed = base.Process(data);
        return $"加密[{processed}]";
    }
}

public class LoggingDecorator : DataProcessorDecorator
{
    public LoggingDecorator(IDataProcessor processor) : base(processor) {}

    public override string Process(string data)
    {
        Console.WriteLine($"处理前数据: {data}");
        string result = base.Process(data);
        Console.WriteLine($"处理后数据: {result}");
        return result;
    }
}

// 使用示例
IDataProcessor processor = new BasicDataProcessor();
processor = new LoggingDecorator(processor);
processor = new EncryptionDecorator(processor);

var result = processor.Process("hello world");
Console.WriteLine($"最终结果: {result}");

6. 依赖注入与控制反转(IoC)

应用场景：管理类之间的依赖关系，提高可测试性和松耦合。

C#实现（使用Microsoft.Extensions.DependencyInjection）：

// 定义服务接口
public interface IEmailService
{
    void SendEmail(string to, string subject, string body);
}

public class SmtpEmailService : IEmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        Console.WriteLine($"通过SMTP发送邮件给 {to}: {subject}");
    }
}

public class OrderService
{
    private readonly IEmailService _emailService;

    public OrderService(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public void PlaceOrder(Order order)
    {
        // 处理订单逻辑...
        _emailService.SendEmail(order.CustomerEmail, "订单确认", "您的订单已收到");
    }
}

// 配置DI容器
var services = new ServiceCollection();
services.AddTransient<IEmailService, SmtpEmailService>();
services.AddTransient<OrderService>();

var provider = services.BuildServiceProvider();

// 使用
var orderService = provider.GetRequiredService<OrderService>();
orderService.PlaceOrder(new Order());

7. 中介者模式(Mediator)

应用场景：当多个对象需要复杂交互时，减少对象间的直接依赖。

C#实现（使用MediatR库）：

// 定义命令
public record PlaceOrderCommand(Order Order) : IRequest<OrderResult>;

// 定义处理器
public class PlaceOrderHandler : IRequestHandler<PlaceOrderCommand, OrderResult>
{
    public async Task<OrderResult> Handle(PlaceOrderCommand request, CancellationToken cancellationToken)
    {
        // 处理订单逻辑
        Console.WriteLine($"处理订单: {request.Order.Id}");
        return new OrderResult(true, "订单处理成功");
    }
}

// 定义结果
public record OrderResult(bool Success, string Message);

// 使用示例
var services = new ServiceCollection();
services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));

var provider = services.BuildServiceProvider();
var mediator = provider.GetRequiredService<IMediator>();

var command = new PlaceOrderCommand(new Order { Id = 1 });
var result = await mediator.Send(command);
Console.WriteLine(result.Message);

设计模式实践建议

  1. 不要过度设计：只在真正需要时应用设计模式，避免为了使用模式而使用模式。
  2. 理解模式本质：深入理解每个模式解决的问题，而不是机械地实现模式结构。
  3. 结合语言特性：利用C#的语言特性（如委托、事件、LINQ等）简化模式实现。
  4. 考虑可测试性：设计模式应提高代码的可测试性，如果不能，可能需要重新考虑实现方式。
  5. 保持简单：简单的解决方案往往比复杂的设计模式更可取。

结论

C#设计模式实践是每个高级开发者必须掌握的技能。通过合理应用这些模式，你可以构建出更加灵活、可维护和可扩展的应用程序。记住，设计模式不是银弹，而是工具箱中的工具，选择正确的工具解决正确的问题才是关键。随着C#语言的不断发展，新的特性和库（如ASP.NET Core的依赖注入系统、MediatR等）为设计模式的实现提供了更加简洁高效的方式，值得开发者持续学习和探索。

a_a_a

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注