C#核心设计模式：工厂模式、单例模式与策略模式

设计模式是软件工程中解决常见问题的可重用方案，它们能提升代码的可维护性、灵活性和复用性。在C#开发中，工厂模式、单例模式和策略模式是三种核心模式，广泛应用于对象创建、实例管理和行为封装。下面我将逐一解释每个模式的定义、目的、优缺点，并提供C#代码示例。所有解释基于标准设计模式原理，确保真实可靠。

1. 工厂模式

定义：工厂模式提供一个接口来创建对象，而不暴露具体实现类。它将对象创建逻辑封装在工厂类中，客户端通过工厂获取对象实例。
目的：解耦对象创建过程，使代码更灵活，便于扩展新类型。例如，在需要创建多种数据库连接或日志记录器时，避免直接实例化具体类。
优点：

• 支持开放-封闭原则：添加新类型时，无需修改现有代码。
• 减少耦合：客户端只依赖接口，而非具体类。
  缺点：
• 工厂类可能成为复杂点，尤其在类型过多时。
• 需要额外工厂类，增加代码量。

C#实现示例：
以下是一个简单工厂模式，用于创建不同类型的日志记录器。

// 定义日志接口
public interface ILogger
{
    void Log(string message);
}

// 具体实现类
public class FileLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"File Log: {message}");
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"Console Log: {message}");
}

// 工厂类
public class LoggerFactory
{
    public ILogger CreateLogger(string type)
    {
        switch (type.ToLower())
        {
            case "file": return new FileLogger();
            case "console": return new ConsoleLogger();
            default: throw new ArgumentException("Invalid logger type");
        }
    }
}

// 客户端使用
class Program
{
    static void Main()
    {
        var factory = new LoggerFactory();
        ILogger logger = factory.CreateLogger("console");
        logger.Log("This is a test message"); // 输出: Console Log: This is a test message
    }
}

2. 单例模式

定义：单例模式确保一个类只有一个实例，并提供全局访问点。它通过私有构造函数和静态属性控制实例化。
目的：管理共享资源，如配置管理、数据库连接池或缓存，避免多个实例导致资源冲突。
优点：

• 保证全局唯一性：节省资源，提高性能。
• 延迟初始化：实例只在首次访问时创建。
  缺点：
• 可能引入全局状态，增加测试难度。
• 线程安全问题需处理，尤其在多线程环境中。

C#实现示例：
以下是一个线程安全的单例模式，使用双重检查锁定确保性能。

public sealed class Singleton
{
    private static Singleton _instance;
    private static readonly object _lock = new object();

    // 私有构造函数
    private Singleton() { }

    // 公共访问点
    public static Singleton Instance
    {
        get
        {
            if (_instance == null) // 第一重检查
            {
                lock (_lock) // 加锁
                {
                    if (_instance == null) // 第二重检查
                    {
                        _instance = new Singleton();
                    }
                }
            }
            return _instance;
        }
    }

    // 示例方法
    public void ShowMessage() => Console.WriteLine("Singleton instance is working.");
}

// 客户端使用
class Program
{
    static void Main()
    {
        Singleton instance1 = Singleton.Instance;
        Singleton instance2 = Singleton.Instance;
        instance1.ShowMessage(); // 输出: Singleton instance is working.
        Console.WriteLine(instance1 == instance2); // 输出: True (证明是同一个实例)
    }
}

3. 策略模式

定义：策略模式定义一系列算法（策略），封装每个算法，并使它们可互换。客户端在运行时选择策略，而不修改代码。
目的：将行为与对象分离，支持动态切换算法。例如，在支付处理或排序算法中，根据条件选择不同策略。
优点：

• 提高扩展性：添加新策略时，无需改动现有代码。
• 消除条件语句：用多态替代if-else或switch-case。
  缺点：
• 可能增加策略类数量，导致类膨胀。
• 客户端需了解策略接口。

C#实现示例：
以下是一个策略模式，用于计算不同折扣策略的订单价格。

// 定义策略接口
public interface IDiscountStrategy
{
    decimal ApplyDiscount(decimal amount);
}

// 具体策略类
public class NoDiscount : IDiscountStrategy
{
    public decimal ApplyDiscount(decimal amount) => amount; // 无折扣
}

public class TenPercentDiscount : IDiscountStrategy
{
    public decimal ApplyDiscount(decimal amount) => amount * 0.9m; // 9折
}

public class FixedDiscount : IDiscountStrategy
{
    public decimal ApplyDiscount(decimal amount) => amount - 50m; // 减50元
}

// 上下文类（使用策略）
public class Order
{
    private IDiscountStrategy _discountStrategy;

    public Order(IDiscountStrategy discountStrategy)
    {
        _discountStrategy = discountStrategy;
    }

    public void SetDiscountStrategy(IDiscountStrategy discountStrategy) => _discountStrategy = discountStrategy;

    public decimal CalculateFinalPrice(decimal amount) => _discountStrategy.ApplyDiscount(amount);
}

// 客户端使用
class Program
{
    static void Main()
    {
        var order = new Order(new NoDiscount());
        Console.WriteLine(order.CalculateFinalPrice(100)); // 输出: 100

        order.SetDiscountStrategy(new TenPercentDiscount());
        Console.WriteLine(order.CalculateFinalPrice(100)); // 输出: 90

        order.SetDiscountStrategy(new FixedDiscount());
        Console.WriteLine(order.CalculateFinalPrice(100)); // 输出: 50
    }
}

总结

工厂模式、单例模式和策略模式是C#中不可或缺的设计模式：

• 工厂模式：专注于对象创建，提升灵活性和解耦。
• 单例模式：确保全局唯一实例，优化资源管理。
• 策略模式：封装可变行为，支持动态算法切换。

在实际开发中，结合使用这些模式能构建健壮、可扩展的应用程序。例如，在电商系统中，单例模式管理配置，工厂模式创建订单对象，策略模式处理支付策略。始终遵循设计原则（如SOLID），避免过度设计。如果您有具体场景或问题，我可以进一步优化解释！