C#设计模式深度解析：经典实现与现代演进 ——基于《设计模式》的.NET技术实践

最新推荐文章于 2025-06-10 18:53:46 发布
最新推荐文章于 2025-06-10 18:53:46 发布
阅读量1k 收藏 11
点赞数 28
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： c# 设计模式 .net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oWanMeiShiKong/article/details/145885390

一、设计模式与C#语言特性融合

C#凭借其面向对象特性、泛型、委托/事件、LINQ等能力，为设计模式提供了更优雅的实现方式。以下通过典型模式展现其技术融合：

1. 工厂方法模式 + 泛型约束

public interface IProduct<T> where T : new()  
{
    void Operate();
}

public class ConcreteProduct<T> : IProduct<T> where T : new()
{
    public void Operate() => Console.WriteLine($"Product {typeof(T).Name}");
}

public class GenericFactory<T> where T : IProduct<T>, new()
{
    public T Create() => new T();
}

// 使用
var factory = new GenericFactory<ConcreteProduct<MyType>>();
var product = factory.Create();

技术要点：

• 泛型工厂实现类型安全的产品创建
• new()约束确保子类具有默认构造函数
• 符合开放-封闭原则，扩展时无需修改工厂类

2. 观察者模式 + 事件委托

public class Subject  
{
    public event EventHandler<EventArgs> StateChanged;
    
    private int _state;
    public int State  
    {
        get => _state;
        set 
        {
            _state = value;
            OnStateChanged();
        }
    }

    protected virtual void OnStateChanged() => 
        StateChanged?.Invoke(this, EventArgs.Empty);
}

public class Observer  
{
    public void Subscribe(Subject subject) => 
        subject.StateChanged += HandleStateChange;
    
    private void HandleStateChange(object sender, EventArgs e) =>
        Console.WriteLine($"State updated to {((Subject)sender).State}");
}

// 使用
var subject = new Subject();
var observer = new Observer();
observer.Subscribe(subject);
subject.State = 42;

优势分析：

• 利用C#内置事件机制消除传统观察者的样板代码
• 避免显式注册/注销接口的实现
• 支持多播委托，天然支持多个观察者

二、创建型模式在DI容器中的蜕变

现代.NET Core的依赖注入容器将工厂模式推向新高度：

1. 建造者模式与Options模式

public class ServiceConfig  
{
    public string Endpoint { get; set; }
    public int Timeout { get; set; }
}

public static class ServiceCollectionExtensions  
{
    public static IServiceCollection ConfigureMyService(
        this IServiceCollection services, 
        Action<ServiceConfig> configure)
    {
        var config = new ServiceConfig();
        configure(config);
        services.AddSingleton(config);
        services.AddTransient<MyService>();
        return services;
    }
}

// 启动配置
services.ConfigureMyService(opt => {
    opt.Endpoint = "https://api.example.com";
    opt.Timeout = 30;
});

模式演进：

• 将对象构造过程封装为流畅接口
• 通过Action委托实现配置的延迟绑定
• 符合现代ASP.NET Core配置范式

三、行为型模式的函数式实现

C#的函数式特性为传统行为模式提供新思路：

1. 策略模式 + Lambda表达式

public class PaymentProcessor  
{
    private Func<decimal, bool> _paymentStrategy;

    public void SetPaymentStrategy(Func<decimal, bool> strategy) => 
        _paymentStrategy = strategy;

    public bool ProcessPayment(decimal amount) => 
        _paymentStrategy?.Invoke(amount) ?? false;
}

// 使用
var processor = new PaymentProcessor();
processor.SetPaymentStrategy(amt => 
    CreditCardService.Charge(amt, "4111111111111111"));
var result = processor.ProcessPayment(100m);

价值提升：

• 消除策略接口的显式定义
• 支持运行时动态替换算法
• 与LINQ表达式树结合可实现更复杂策略

2. 责任链模式 + 中间件管道

ASP.NET Core中间件本质是责任链模式的应用：

public class LoggingMiddleware  
{
    private readonly RequestDelegate _next;

    public LoggingMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext context)  
    {
        LogRequest(context.Request);
        await _next(context);
        LogResponse(context.Response);
    }
}

// 管道配置
app.UseMiddleware<LoggingMiddleware>();
app.UseMiddleware<AuthenticationMiddleware>();

架构意义：

• 每个中间件只关注单一职责
• 通过RequestDelegate实现链式传递
• 支持动态插入/移除处理节点

四、结构型模式在跨进程通信中的应用

1. 代理模式 + gRPC服务

// 定义服务契约
public interface IDataService  
{
    Task<DataResponse> GetData(DataRequest request);
}

// 客户端代理
public class DataServiceProxy : IDataService  
{
    private readonly Channel _channel;
    private readonly DataService.DataServiceClient _client;

    public DataServiceProxy(string address)  
    {
        _channel = new Channel(address, ChannelCredentials.Insecure);
        _client = new DataService.DataServiceClient(_channel);
    }

    public async Task<DataResponse> GetData(DataRequest request) => 
        await _client.GetDataAsync(request);
}

// 使用
var proxy = new DataServiceProxy("localhost:50051");
var response = await proxy.GetData(new DataRequest { Id = 123 });

模式升级：

• 将本地接口代理转换为远程服务调用
• 自动处理序列化/反序列化
• 支持负载均衡与熔断机制

五、模式反模式：C#特定场景的陷阱

1. 单例模式的线程安全实现

public class Singleton  
{
    private static readonly Lazy<Singleton> _instance = 
        new Lazy<Singleton>(() => new Singleton(), true);
    
    private Singleton() { }

    public static Singleton Instance => _instance.Value;
}

最佳实践：

• 使用Lazy实现延迟初始化
• 确保线程安全的实例创建
• 防止反射攻击的构造函数保护

2. 装饰器模式与扩展方法

public interface IDataCache  
{
    string Get(string key);
}

public class DataCache : IDataCache { /* 基础实现 */ }

public static class DataCacheDecorators  
{
    public static IDataCache WithLogging(this IDataCache cache) => 
        new LoggingDecorator(cache);
}

public class LoggingDecorator : IDataCache  
{
    private readonly IDataCache _inner;

    public LoggingDecorator(IDataCache inner) => _inner = inner;

    public string Get(string key)  
    {
        Console.WriteLine($"Accessing key: {key}");
        return _inner.Get(key);
    }
}

// 使用
var cache = new DataCache().WithLogging();

创新点：

• 通过扩展方法实现流畅装饰
• 保持接口一致性
• 支持多层装饰器嵌套

六、现代架构的模式融合

1. CQRS模式与Mediator模式

public interface ICommandHandler<TCommand>  
{
    Task Handle(TCommand command);
}

public class CreateUserHandler : ICommandHandler<CreateUserCommand>  
{
    public Task Handle(CreateUserCommand command)  
    {
        // 实现业务逻辑
        return Task.CompletedTask;
    }
}

public class Mediator  
{
    private readonly IServiceProvider _provider;

    public Mediator(IServiceProvider provider) => _provider = provider;

    public Task Send<TCommand>(TCommand command)  
    {
        var handler = _provider.GetService<ICommandHandler<TCommand>>();
        return handler.Handle(command);
    }
}

// 使用
var mediator = new Mediator(serviceProvider);
await mediator.Send(new CreateUserCommand { Name = "Alice" });

架构价值：

• 解耦命令发起者与处理者
• 支持横切关注点（如日志、验证）的集中处理
• 符合单一职责原则

结论：C#设计模式的演进图谱

模式类型 传统实现 现代演进
创建型 简单工厂 DI容器 + Options模式
结构型 类适配器 跨进程服务代理（gRPC/DAPR）
行为型 接口策略 函数委托 + 表达式树
在.NET 6+与云原生时代，C#设计模式呈现三大趋势：
1. 声明式编程：通过特性注解替代显式模式实现
2. 响应式融合：结合Rx.NET实现事件驱动架构
3. 元编程赋能：利用Source Generator自动生成模式代码
掌握模式本质而非具体实现形式，方能在复杂系统设计中游刃有余。

参考文献

  1. 《设计模式：可复用面向对象软件的基础》GoF
  2. 《C# in Depth》Jon Skeet
  3. .NET官方文档：Dependency Injection in ASP.NET Core
  4. gRPC官方文档：C# Quick Start Guide
C#设计模式_设计模式_C#_
10-01
创建型： 1. 单件模式(Singleton Pattern) 2. 抽象工厂（Abstract Factory） 3. 建造者模式(Builder) 4. 工厂方法模式（Factory Method) 5. 原型模式(Prototype)结构型： 6. 适配器模式（Adapter Pattern) 7. 桥接模式（Bridge Pattern) 8. 装饰模式(Decorator Pattern) 9. 组合模式(Composite Pattern) 10. 外观模式（Facade Pattern) 11. 享元模式(Flyweight Pattern) 12. 代理模式(Proxy Pattern) 行为型： 13. 模板方法(Template Method) 14. 命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 16. 观察者模式(Observer Pattern） 17. 解释器模式(Interpreter Pattern) 18. 中介者模式(Mediator Pattern) 19. 职责链模式(Chain of Responsibility Pattern) 20. 备忘录模式(Memento Pattern) 21. 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)
C#设计模式总结
dz45693的专栏
09-29 4312
一、引言 　　经过这段时间对设计模式的学习，自己的感触还是很多的，因为我现在在写代码的时候，经常会想想这里能不能用什么设计模式来进行重构。所以，学完设计模式之后，感觉它会慢慢地影响到你写代码的思维方式。这里对设计模式做一个总结，一来可以对所有设计模式进行一个梳理，二来可以做一个索引来帮助大家收藏。 　　PS: 其实，很早之前我就看过所有的设计模式了，但是并没有写博客，但是不久就很快忘记
C#设计模式
最新发布
weixin_61819056的博客
06-10 1252
C#常用设计模式摘要（150字）： 本文介绍了C#中五种创建型设计模式：1) 单例模式确保类唯一实例，适用于全局对象；2) 工厂模式封装对象创建逻辑，通过统一接口生成不同产品；3) 抽象工厂创建产品族，无需指定具体类；4) 建造者模式分离复杂对象的构建与表示，支持多样化配置；5) 原型模式通过克隆而非新建来复制对象。每种模式均包含C#代码示例和典型应用场景，如日志系统、配置管理等。这些模式可有效提升代码复用性和灵活性。
C#：设计模式
ypcyyds_的博客
08-14 566
设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，设计模式（Design pattern）代表了最佳的实践。3)行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)。其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。2)结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
c# 设计模式
qq_44230029的博客
03-10 883
不同的设计模式有其优点和缺点，并不是所有场景都需要使用相应的设计模式，但如果熟悉设计模式，那么在编程设计时会自然而然的使用到，比如单例模式、工厂方法模式、外观模式、观察者模式、备忘录模式等。
C#的设计模式
weixin_40593924的博客
10-29 670
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性，毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式...
【C#类库开发】核心模块与最佳实践总结：从基础类库到企业级工具类设计的全面解析了C#类
05-27
内容概要：本文总结了C#类库多年积累的核心模块与最佳实践，涵盖基础类库、常用第三方库、设计模式与最佳实践，以及工具类开发经验。基础类库部分深入解析了.NET Framework/Core原生类库的高效使用，如System....
C#工程化实现设计模式：王翔解析与扩展
"设计模式(基于C#工程化实现及...《设计模式——基于C#的工程化实现及扩展》不仅是一本介绍设计模式的书籍，它还是一个探讨如何在C#环境中有效运用和扩展设计模式的实践指南，旨在帮助开发者提高软件工程的效率和质量。
C#设计模式实战：工程化实现与扩展探索
"《设计模式_基于C#的工程化实现及扩展》是一本由王翔老师撰写的书籍，旨在探讨如何在C#环境中高效且灵活地应用设计模式。本书结合作者的项目实践经验，对经典的23种设计模式进行了深入探讨，并融入了新的视角和实现...
C#项目中常用到的设计模式
09-23
在C#项目开发中，设计模式的应用对于构建高效、可维护和可扩展的代码至关重要。设计模式是软件工程中经过时间检验的一套解决方案，可以用来解决特定设计问题。在项目开发的不同阶段，如功能添加和代码重构过程中，...
C#设计模式源代码深度解析
C#是一种流行的面向对象编程语言，它在设计模式的应用方面提供了丰富的支持。设计模式是软件工程中用于解决常见问题的经过验证的解决方案模板。在C#中应用设计模式不仅可以提高代码的可维护性、可扩展性，而且可以...
c#设计模式
09-10
将23个设计模式整理到同一个工程里，仅供参考学习 .
C# 设计模式
weixin_48556214的博客
08-02 142
享元模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值