.NET工厂方法模式讲解

《.NET工厂方法模式讲解》

一、设计模式与工厂方法模式概述

设计模式是软件开发中解决特定问题的可复用方案，而工厂方法模式（Factory Method Pattern）作为创建型模式的核心成员，通过定义一个创建对象的接口，但将实际对象的创建延迟到子类中完成。这种模式在.NET开发中尤其适用于需要动态决定实例化类型、解耦客户端代码与具体类、或需要扩展产品创建逻辑的场景。

传统直接实例化（如new ConcreteProduct()）会导致客户端与具体类强耦合，违反开闭原则。工厂方法模式通过引入抽象工厂角色，将创建逻辑封装在工厂类中，客户端只需调用工厂的抽象方法即可获取对象，无需关心具体实现。

二、工厂方法模式的结构与角色

工厂方法模式包含四个核心角色：

1. 抽象产品（Product）：定义产品的公共接口

2. 具体产品（ConcreteProduct）：实现抽象产品的接口

3. 抽象创建者（Creator）：声明工厂方法，返回产品类型对象

4. 具体创建者（ConcreteCreator）：实现工厂方法，返回具体产品实例

三、.NET中的工厂方法模式实现

3.1 基础实现示例

假设需要开发一个日志系统，支持不同存储方式（文件、数据库），使用工厂方法模式实现如下：

// 抽象产品
public interface ILogger
{
    void Log(string message);
}

// 具体产品1
public class FileLogger : ILogger
{
    public void Log(string message)
    {
        File.AppendAllText("log.txt", $"{DateTime.Now}: {message}\n");
    }
}

// 具体产品2
public class DatabaseLogger : ILogger
{
    public void Log(string message)
    {
        // 模拟数据库写入
        Console.WriteLine($"Database log: {message}");
    }
}

// 抽象创建者
public abstract class LoggerCreator
{
    public abstract ILogger CreateLogger();
    
    public void LogMessage(string message)
    {
        ILogger logger = CreateLogger();
        logger.Log(message);
    }
}

// 具体创建者1
public class FileLoggerCreator : LoggerCreator
{
    public override ILogger CreateLogger()
    {
        return new FileLogger();
    }
}

// 具体创建者2
public class DatabaseLoggerCreator : LoggerCreator
{
    public override ILogger CreateLogger()
    {
        return new DatabaseLogger();
    }
}

// 客户端使用
var fileCreator = new FileLoggerCreator();
fileCreator.LogMessage("This is a file log");

var dbCreator = new DatabaseLoggerCreator();
dbCreator.LogMessage("This is a database log");

3.2 依赖注入中的工厂方法

在ASP.NET Core中，工厂方法模式常与依赖注入结合使用。通过实现IFactory接口，可以在运行时动态创建服务实例：

public interface ILoggerFactory
{
    ILogger CreateLogger(string categoryName);
}

public class ConsoleLoggerFactory : ILoggerFactory
{
    public ILogger CreateLogger(string categoryName)
    {
        return new ConsoleLogger(categoryName);
    }
}

// Startup.cs中配置
services.AddSingleton();
services.AddTransient(provider => 
{
    var factory = provider.GetRequiredService();
    return factory.CreateLogger("Default");
});

3.3 泛型工厂方法实现

使用泛型可以创建更灵活的工厂，避免为每个产品类型编写单独的工厂类：

public abstract class GenericCreator where T : new()
{
    public virtual T Create()
    {
        return new T();
    }
}

// 具体产品
public class Order { }
public class Customer { }

// 具体创建者
public class OrderCreator : GenericCreator { }
public class CustomerCreator : GenericCreator { }

// 使用
var orderCreator = new OrderCreator();
Order order = orderCreator.Create();

四、工厂方法模式的应用场景

4.1 动态产品创建

当系统需要根据运行时条件（如配置文件、用户输入）决定创建哪种产品时，工厂方法模式非常适用。例如：

public enum LoggerType { File, Database }

public class DynamicLoggerCreator : LoggerCreator
{
    private readonly LoggerType _type;
    
    public DynamicLoggerCreator(LoggerType type)
    {
        _type = type;
    }
    
    public override ILogger CreateLogger()
    {
        return _type switch
        {
            LoggerType.File => new FileLogger(),
            LoggerType.Database => new DatabaseLogger(),
            _ => throw new ArgumentException("Invalid logger type")
        };
    }
}

4.2 框架开发中的使用

在开发框架时，工厂方法模式允许用户扩展功能而不修改框架核心代码。例如，ASP.NET Core中的IHostBuilder使用工厂方法模式创建服务：

public interface IHostBuilder
{
    IHost Build();
}

public class DefaultHostBuilder : IHostBuilder
{
    public IHost Build()
    {
        // 复杂的初始化逻辑
        return new DefaultHost();
    }
}

4.3 单元测试中的模拟

在单元测试中，可以通过继承抽象创建者并返回模拟对象来测试客户端代码：

public class MockLogger : ILogger
{
    public void Log(string message)
    {
        // 记录测试日志
    }
}

public class MockLoggerCreator : LoggerCreator
{
    public override ILogger CreateLogger()
    {
        return new MockLogger();
    }
}

// 测试代码
[Test]
public void LogMessage_ShouldCallLogger()
{
    var creator = new MockLoggerCreator();
    creator.LogMessage("Test message");
    // 验证MockLogger是否被调用
}

五、工厂方法模式与其他模式的比较

5.1 与简单工厂模式的区别

简单工厂模式使用单个工厂类通过条件语句创建对象，违反开闭原则。工厂方法模式通过子类化实现扩展，更符合开闭原则。

5.2 与抽象工厂模式的区别

抽象工厂模式创建相关对象家族，而工厂方法模式只创建单个产品。当需要创建多个相关产品时，应使用抽象工厂模式。

5.3 与依赖注入的关系

依赖注入框架（如.NET Core的DI容器）本质上是更高级的工厂实现。工厂方法模式可以看作是手动实现的简单DI。

六、.NET中的实际案例分析

6.1 Entity Framework Core的DbContext创建

EF Core使用工厂方法模式创建DbContext实例：

public class ApplicationDbContextFactory : IDesignTimeDbContextFactory
{
    public ApplicationDbContext CreateDbContext(string[] args)
    {
        var optionsBuilder = new DbContextOptionsBuilder();
        optionsBuilder.UseSqlServer("ConnectionString");
        return new ApplicationDbContext(optionsBuilder.Options);
    }
}

6.2 ASP.NET Core的中间件管道

中间件管道通过工厂方法模式创建和配置中间件：

public static IApplicationBuilder UseMiddleware(
    this IApplicationBuilder app,
    params object[] args)
{
    return app.Use(next =>
    {
        var middleware = (TMiddleware)ActivatorUtilities.CreateInstance(app.ApplicationServices, typeof(TMiddleware), args);
        return context => 
        {
            var invokeMethod = middleware.GetType().GetMethod("Invoke");
            return (Task)invokeMethod.Invoke(middleware, new object[] { context, next });
        };
    });
}

七、工厂方法模式的优缺点

7.1 优点

1. 符合开闭原则：新增产品类型只需添加新类，无需修改现有代码

2. 解耦客户端与具体产品：客户端只需知道抽象产品接口

3. 支持多态创建：不同子类可以返回不同产品实例

4. 便于单元测试：可以轻松替换为模拟对象

7.2 缺点

1. 增加类数量：每个具体产品需要对应的创建者类

2. 客户端需要知道具体创建者：虽然解耦了产品，但客户端仍需选择正确的创建者

3. 抽象层复杂度：对于简单场景可能过度设计

八、最佳实践与注意事项

8.1 何时使用工厂方法模式

1. 当类不能预见需要创建哪种类的对象时

2. 当类希望其子类指定它所创建的对象时

3. 当需要将创建对象的代码委托给多个帮助子类中的一个时

8.2 避免的常见错误

1. 过度使用：不是所有对象创建都需要工厂方法

2. 违反单一职责：工厂类应仅负责对象创建

3. 忽略异常处理：工厂方法应妥善处理对象创建失败的情况

8.3 与.NET特性的结合

1. 使用活动模式（Activator Pattern）简化创建

2. 结合泛型约束提高类型安全性

3. 利用依赖注入容器管理工厂生命周期

九、总结与扩展

工厂方法模式是.NET开发中实现对象创建解耦的强大工具。通过将创建逻辑封装在工厂类中，提高了代码的可维护性和可扩展性。在实际开发中，应根据具体场景选择合适的实现方式：简单场景可使用泛型工厂，复杂场景可结合依赖注入，框架开发可参考ASP.NET Core的实现方式。

进一步学习可探索：

1. 工厂方法模式与生成器模式的结合使用

2. 在微服务架构中应用工厂方法模式

3. 使用源代码生成器自动生成工厂代码

关键词：.NET设计模式、工厂方法模式、C#实现、创建型模式、依赖注入、泛型工厂、ASP.NET Core、Entity Framework、单元测试、开闭原则

简介：本文详细讲解了.NET中工厂方法设计模式的实现原理与应用场景，通过代码示例展示了基础实现、依赖注入集成、泛型工厂等高级用法，分析了该模式在ASP.NET Core、Entity Framework等框架中的实际应用，并对比了与其他创建型模式的区别，最后提供了最佳实践与注意事项。