工厂模式实现三种方式

实现工厂模式的方式有以下三种：

1. 简单工厂模式：通过一个工厂类来创建对象实例，客户端只需提供所需产品的类型即可。实现方式比较简单，但是不够灵活，新增产品时需要修改工厂类。

2. 工厂方法模式：将工厂类抽象成一个接口，让子类来决定具体创建哪个产品。客户端只需知道工厂接口和相应产品接口即可。更加灵活，但是需要定义大量的接口和类。

3. 抽象工厂模式：用于创建一系列相关的产品对象，为这些产品提供一个共同的接口。客户端只需要知道抽象工厂接口和相应产品接口即可。适用于产品族的创建。

一、简单工厂模式

简单工厂模式是创建型设计模式之一，它通过一个工厂类来创建对象实例，而不是直接使用 new 关键字来实例化对象。在该模式中，客户端只需知道所需产品的类型即可，而无需关心实际的实现细节。

简单工厂模式适用于以下场景：

1. 需要创建的对象较少，不会经常增加新的产品。

2. 客户端只需要知道所需产品的类型，而无需关心实现细节。

3. 类的创建过程比较简单，且客户端无需知道类的创建细节。

在 .NET Core 源码中，简单工厂模式的应用非常广泛，例如：

1. System.Configuration.ConfigurationManager 类中的 GetSection() 方法，用于获取指定配置节的信息。

2. System.IO.File 类中的 Create() 方法，用于创建指定文件的 FileStream 对象。

3. System.Net.WebRequest 类中的 Create() 方法，用于创建 WebRequest 对象。

以上这些方法都是使用简单工厂模式实现的，它们根据参数类型的不同来创建不同的对象实例。

简单工厂模式在 .NET Core 源码中的实现事例

public interface ILogger
{
    void Log(string message);
}

public class FileLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(#34;Logging to file: {message}");
    }
}

public class DatabaseLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(#34;Logging to database: {message}");
    }
}

public static class LoggerFactory
{
    public static ILogger GetLogger(string loggerType)
    {
        switch (loggerType.ToLower())
        {
            case "file":
                return new FileLogger();
            case "database":
                return new DatabaseLogger();
            default:
                throw new ArgumentException(#34;Invalid logger type: {loggerType}");
        }
    }
}

// 使用示例
ILogger logger = LoggerFactory.GetLogger("file");
logger.Log("Hello, world!");

在上面的例子中，我们定义了一个 `ILogger` 接口和两个实现类 `FileLogger` 和 `DatabaseLogger`。然后通过 `LoggerFactory` 工厂类来创建具体的 `ILogger` 实例，客户端只需要提供所需的 `loggerType` 参数即可。在使用时，先通过工厂类获取对应的实例，然后调用其 `Log()` 方法输出日志。

工厂方法模式在 .NET Core 源码中使用

一个典型的例子就是 EF Core 中的 `DbContext` 类。`DbContext` 用于与数据库交互，而不同的数据库需要使用不同的数据库提供程序（或称为“数据驱动程序”）。EF Core 的工厂方法模式实现了让用户自行选择所需数据库提供程序的功能。

下面以 SQLite 数据库提供程序为例，演示 EF Core 中工厂方法模式的实现：

首先，定义一个抽象的 `DbContext` 工厂类：

public abstract class DbContextFactory
{
    protected abstract DbContext CreateNewInstance(string connectionString);

    public DbContext Create(string connectionString)
    {
        return CreateNewInstance(connectionString);
    }
}

然后，定义一个具体的 `SQLiteDbContextFactory` 工厂类，继承自抽象工厂类，并实现具体的 `CreateNewInstance()` 方法，用于创建 SQLite 数据库的 `DbContext` 实例：

public class SQLiteDbContextFactory : DbContextFactory
{
    protected override DbContext CreateNewInstance(string connectionString)
    {
        var optionsBuilder = new DbContextOptionsBuilder();
        optionsBuilder.UseSqlite(connectionString);

        return new SQLiteDbContext(optionsBuilder.Options);
    }
}

注意到上述代码中，我们通过 `DbContextOptionsBuilder` 类创建了 `DbContext` 的选项，并将其传递给实际创建实例的构造函数。

最后，使用时，只需要先创建一个具体的 `DbContextFactory` 实例，然后调用其 `Create()` 方法创建所需的 `DbContext` 实例即可：

var factory = new SQLiteDbContextFactory();
var context = factory.Create("Data Source=example.db");

在上述代码中，我们创建了一个 `SQLiteDbContextFactory` 实例，并使用其 `Create()` 方法创建了一个 SQLite 数据库连接的 `DbContext` 实例。

总之，工厂方法模式是一种很常见的设计模式，在 .NET Core 中得到了广泛应用。`DbContext` 工厂也是其中的一个经典例子。

抽象工厂模式在 .NET Core 中也有应用

最常见的就是 ADO.NET 中的数据提供程序（Data Provider）。

首先，定义一个抽象的 `DbProviderFactory` 类，表示一个通用的数据库提供程序工厂：

public abstract class DbProviderFactory
{
    public abstract DbCommand CreateCommand();
    public abstract DbConnection CreateConnection();
    public abstract DbParameter CreateParameter();
}

注意到上面的 `DbProviderFactory` 类中定义了三个抽象方法，分别用于创建 `DbCommand`、`DbConnection` 和 `DbParameter` 对象。这些对象都是和数据库相关的核心对象。

接着，定义一个具体的 `SqlClientFactory` 类，继承自抽象工厂类，并实现具体的 `Create*()` 方法，用于创建 Microsoft SQL Server 数据库提供程序的对象：

public class SqlClientFactory : DbProviderFactory
{
    public override DbCommand CreateCommand()
    {
        return new SqlCommand();
    }

    public override DbConnection CreateConnection()
    {
        return new SqlConnection();
    }

    public override DbParameter CreateParameter()
    {
        return new SqlParameter();
    }
}

类似的，还可以定义其他的具体工厂类，用于创建不同的数据库提供程序对象。

最后，在使用时，只需要先创建一个具体的 `DbProviderFactory` 实例，然后调用其 `Create*()` 方法即可创建所需的对象（如 `DbCommand`、`DbConnection` 等）：

// 创建一个 SQL Server 数据库提供程序工厂实例
var factory = SqlClientFactory.Instance;

// 使用该工厂创建对象
using (var connection = factory.CreateConnection())
{
    connection.ConnectionString = connectionString;
    connection.Open();

    using (var command = factory.CreateCommand())
    {
        command.CommandText = "SELECT * FROM Customers";
        command.Connection = connection;

        using (var reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                // 读取数据
            }
        }
    }
}

上述代码中，我们首先创建了一个 `SqlClientFactory` 实例，然后使用该实例创建了 `SqlConnection` 和 `SqlCommand` 对象。注意到，在使用 `DbCommand` 和 `DbConnection` 等对象时，并没有直接写明其具体的类型，而是通过 `DbProviderFactory` 提供的抽象方法进行了创建，这正是抽象工厂模式的精髓所在。

综上，抽象工厂模式在 .NET Core 中得到广泛应用，尤其是在 ADO.NET 数据提供程序中。通过使用抽象工厂模式，我们可以轻松地切换不同的数据库提供程序，加强了系统的灵活性和可扩展性。