设计模式在C#中的应用
项目地址: https://gitcode.com/DotNetGuide/DotNetGuide 本文详细介绍了三种常见的设计模式在C#中的实现方式及其应用场景。首先探讨了单例模式的多种实现方式，包括饿汉式、懒汉式和懒加载式，分析了它们的优缺点及适用场景。接着讨论了工厂模式与依赖注入的结合使用，展示了如何通过工厂模式动态创建对象，并通过依赖注入管理对象的生命周期和依赖关系。最后，深入解析了观察者模式在事件驱动编程中的应用，通过C#的事件和委托机制实现松耦合的通知系统。
单例模式的多种实现方式
单例模式是设计模式中最简单也是最常用的一种模式，它确保一个类只有一个实例，并提供一个全局访问点。在C#中，单例模式有多种实现方式，每种方式都有其适用场景和优缺点。本节将详细介绍三种常见的单例模式实现方式：饿汉式、懒汉式和懒加载式。
1. 饿汉式单例模式
饿汉式单例模式在类加载时就完成了初始化，因此类加载较慢，但获取对象的速度快。这种方式基于类加载机制避免了多线程同步问题，但可能会造成资源浪费。
public class SingletonEager
{
private SingletonEager() { }
private static readonly SingletonEager _instance = new SingletonEager();
public static SingletonEager Instance
{
get { return _instance; }
}
public void DoSomething()
{
Console.WriteLine("饿汉式单例模式.");
}
}
特点：
- 线程安全：由于实例在类加载时就已经创建，因此天然线程安全。
- 资源占用：如果实例未被使用，可能会浪费内存资源。
2. 懒汉式单例模式
懒汉式单例模式在第一次使用时才创建实例，避免了资源浪费，但需要处理多线程环境下的同步问题。
public class SingletonLazy
{
private SingletonLazy() { }
private static SingletonLazy? _instance;
private static readonly object _lockObj = new object();
public static SingletonLazy Instance
{
get
{
if (_instance == null)
{
lock (_lockObj)
{
_instance ??= new SingletonLazy();
}
}
return _instance;
}
}
public void DoSomething()
{
Console.WriteLine("懒汉式单例模式.");
}
}
特点：
- 延迟加载：实例在第一次访问时才创建。
- 线程安全：通过双重检查锁定机制确保线程安全。
- 性能开销：每次访问实例时都需要检查锁，可能影响性能。
3. 懒加载单例模式（使用Lazy ）
C#提供了Lazy<T>类型，可以更优雅地实现懒加载单例模式，既保证了线程安全，又简化了代码。
public sealed class SingletonByLazy
{
private static readonly Lazy<SingletonByLazy> _lazy = new Lazy<SingletonByLazy>(() => new SingletonByLazy());
public static SingletonByLazy Instance { get { return _lazy.Value; } }
private SingletonByLazy() { }
public void DoSomething()
{
Console.WriteLine("懒加载单例模式.");
}
}
特点：
- 延迟加载：实例在第一次访问时才创建。
- 线程安全：
Lazy<T>内部已经处理了线程安全问题。 - 代码简洁：无需手动实现锁机制，代码更加简洁。
对比表格
| 实现方式 | 线程安全 | 延迟加载 | 性能开销 | 代码复杂度 |
|---|---|---|---|---|
| 饿汉式 | 是 | 否 | 低 | 低 |
| 懒汉式 | 是 | 是 | 中 | 中 |
| 懒加载（Lazy） | 是 | 是 | 低 | 低 |
流程图：单例模式的选择
csharp // 定义接口 public interface ILogger { void Log(string message); }
// 具体实现 public class FileLogger : ILogger { public void Log(string message) { Console.WriteLine($"FileLogger: {message}"); } }
public class ConsoleLogger : ILogger { public void Log(string message) { Console.WriteLine($"ConsoleLogger: {message}"); } }
// 工厂接口 public interface ILoggerFactory { ILogger CreateLogger(string type); }
// 工厂实现 public class LoggerFactory : ILoggerFactory { public ILogger CreateLogger(string type) { return type switch { "file" => new FileLogger(), "console" => new ConsoleLogger(), _ => throw new ArgumentException("Invalid logger type"), }; } }
// 服务类 public class LoggingService { private readonly ILogger _logger;
public LoggingService(ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger("console"); // 动态选择日志类型
}
public void LogMessage(string message)
{
_logger.Log(message);
}
}
// 在.NET Core中注册依赖 public class Startup { public void ConfigureServices(IServiceCollection services) { services.AddSingleton<ILoggerFactory, LoggerFactory>(); services.AddTransient (); } }
#### 流程图
以下是一个流程图，展示了工厂模式与依赖注入的结合过程：
#### 表格对比
| 模式 | 解决的问题 | 适用场景 |
|---------------|------------------------------|----------------------------|
| 工厂模式 | 对象创建的复杂性 | 动态对象创建、多态需求 |
| 依赖注入 | 对象依赖关系的管理 | 解耦、可测试性、生命周期管理 |
通过结合工厂模式和依赖注入，开发者可以更灵活地管理对象的创建和依赖关系，从而编写出更易于维护和扩展的代码。
## 观察者模式在事件驱动中的应用
观察者模式是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在C#中，观察者模式通常通过事件（`event`）和委托（`delegate`）机制实现，非常适合用于事件驱动的编程场景。
### 观察者模式的核心组件
观察者模式包含以下核心组件：
1. **Subject（主题）**：维护一个观察者列表，提供添加和删除观察者的方法，并在状态变化时通知观察者。
2. **Observer（观察者）**：定义一个更新接口，用于接收主题的通知并做出响应。
在C#中，`Subject`通常是一个类，通过事件机制通知观察者；`Observer`则是订阅这些事件的方法或对象。
### 事件驱动的实现
C#中的事件机制是观察者模式的典型实现。以下是一个简单的示例，展示如何使用事件和委托实现观察者模式：
```csharp
using System;
// 定义事件参数
public class NotificationEventArgs : EventArgs
{
public string Message { get; }
public NotificationEventArgs(string message)
{
Message = message;
}
}
// Subject（主题）
public class NotificationService
{
// 定义事件
public event EventHandler<NotificationEventArgs> NotificationSent;
// 触发事件的方法
public void SendNotification(string message)
{
Console.WriteLine($"发送通知：{message}");
OnNotificationSent(new NotificationEventArgs(message));
}
protected virtual void OnNotificationSent(NotificationEventArgs e)
{
NotificationSent?.Invoke(this, e);
}
}
// Observer（观察者）
public class User
{
public string Name { get; }
public User(string name)
{
Name = name;
}
// 事件处理方法
public void HandleNotification(object sender, NotificationEventArgs e)
{
Console.WriteLine($"{Name} 收到通知：{e.Message}");
}
}
// 使用示例
class Program
{
static void Main(string[] args)
{
var notificationService = new NotificationService();
var user1 = new User("Alice");
var user2 = new User("Bob");
// 订阅事件
notificationService.NotificationSent += user1.HandleNotification;
notificationService.NotificationSent += user2.HandleNotification;
// 触发事件
notificationService.SendNotification("系统更新通知");
}
}
流程图
以下是一个简单的流程图，展示观察者模式在事件驱动中的工作流程：
表格：观察者模式与事件驱动的对比
| 特性 | 观察者模式 | 事件驱动 |
|---|---|---|
| 实现方式 | 基于接口或抽象类 | 基于委托和事件 |
| 耦合度 | 较低（松耦合） | 较低（松耦合） |
| 适用场景 | 需要动态添加或删除观察者 | 需要异步或解耦的通知机制 |
| C#中的典型应用 | IObserver<T> 和 IObservable<T> | event 和 EventHandler |
实际应用场景
观察者模式在以下场景中非常有用：
- 用户界面事件：如按钮点击、鼠标移动等。
- 消息队列：如发布-订阅系统。
- 日志系统：多个日志记录器订阅日志事件。
通过事件驱动的观察者模式，可以轻松实现松耦合的系统设计，提高代码的可维护性和扩展性。
总结
设计模式是软件开发中解决常见问题的经典方案，本文通过C#语言展示了单例模式、工厂模式和观察者模式的具体实现及其实际应用。单例模式确保一个类只有一个实例，工厂模式封装对象创建逻辑，观察者模式实现松耦合的事件通知机制。结合依赖注入等现代编程技术，这些模式能够显著提升代码的可维护性、可扩展性和可测试性。掌握这些设计模式及其在C#中的实现方式，有助于开发者编写更加高效、灵活的代码。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
