设计模式01：创建型设计模式之单例、简单工厂的使用情景及其基础Demo

一、单例模式

1.情景

连接字符串管理

2.好处

• 代码简洁：可全局访问连接字符串。
• 性能优化：一个程序一个连接实例，避免反复创建对象（连接）和销毁对象（连接）。
• 线程安全：连接对象不会被重复创建，从而避免并发冲突。

3.Demo

using System;
using SqlSugar;

public class SqlSugarSingleton
{
    // 使用 Lazy 来保证延迟初始化和线程安全
    //Lazy 通过内部的机制确保在多线程环境下的安全性，而且在首次访问时才会初始化对象实例，从而避免了重复创建和资源浪费。
    private static readonly Lazy lazyInstance = new Lazy(() =>
    {
        // 配置 SqlSugarClient 实例
        return new SqlSugarClient(new ConnectionConfig
        {
            ConnectionString = "Server=localhost;Database=TestDB;User Id=myuser;Password=mypassword;",
            DbType = DbType.MySql, // 根据你的数据库类型选择
            IsAutoCloseConnection = true,
            InitKeyType = InitKeyType.Attribute
        });
    });

    // 获取 SqlSugarClient 实例
    public static SqlSugarClient Instance => lazyInstance.Value;
}

class Program
{
    static void Main()
    {
        // 获取唯一的 SqlSugarClient 实例
        SqlSugarClient db = SqlSugarSingleton.Instance;

        // 示例查询
        var result = db.Queryable()
                       .Where(s => s.Age > 18)
                       .ToList();

        Console.WriteLine($"查询结果数量: {result.Count}");
    }
}

// 假设我们有一个学生类，用于展示查询操作
public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

二、简单工厂模式

1.情景 

        可由参数决定实例化哪个类，不同的类调用相同的方法有不同的效果。

2.好处

• 便于开发：无需知道具体类的实现细节，只需要通过入参实现想要的效果
• 扩展方便：若要增加或者修改，对抽象类的子类操作即可，不需要改客户端代码（Main函数）
• 简单简洁：减少了客户端（Main函数）的复杂度，调用时简洁大方。

3.代码思路

• 抽象类和子类：写一个抽象类（含抽象方法），再写n个它的子类（及其父类抽象方法的实现）
• 工厂类：写一个简单工厂，由字符串决定要实例化的类
• 客户端使用：先用简单工厂创建对象，然后再用这个对象调用方法

4.Demo

using System;

// 抽象产品类 （先写一个抽象类，含有抽象方法）
public abstract class Product
{
    public abstract void Show();
}

// 具体产品 A （再写n个它的子类，及其父类抽象方法的实现）
public class ConcreteProductA : Product
{
    public override void Show()
    {
        Console.WriteLine("ConcreteProductA");
    }
}

// 具体产品 B
public class ConcreteProductB : Product
{
    public override void Show()
    {
        Console.WriteLine("ConcreteProductB");
    }
}

// 简单工厂 （然后，写一个简单工厂，由字符串决定要实例化的类）
public class ProductFactory
{
    public static Product CreateProduct(string type)
    {
        if (type == "A")
            return new ConcreteProductA();
        else if (type == "B")
            return new ConcreteProductB();
        else
            throw new ArgumentException("Invalid product type");
    }
}

class Program
{
    static void Main()
    {
        
        //客户端使用：先用简单工厂创建对象，然后再用这个对象调用方法
        Product productA = ProductFactory.CreateProduct("A");
        productA.Show();

        Product productB = ProductFactory.CreateProduct("B");
        productB.Show();
    }
}

5.语法糖下的简单工厂

using System;
using System.Collections;
using System.Collections.Generic;

// 抽象产品类
public abstract class Product
{
    public abstract void Show();
}

// 具体产品 A
public class ConcreteProductA : Product
{
    public override void Show()
    {
        Console.WriteLine("ConcreteProductA");
    }
}

// 具体产品 B
public class ConcreteProductB : Product
{
    public override void Show()
    {
        Console.WriteLine("ConcreteProductB");
    }
}

public class FactoryDictionary
{
    // 字典存储类型映射，客户端可以直接访问
    public static readonly Dictionary dict = new Dictionary()
    {
        { "A", new ConcreteProductA() },
        { "B", new ConcreteProductB() }
    };
}

class Program
{
    static void Main()
    {
        // 客户端直接使用字典创建产品
        if (FactoryDictionary.dict.TryGetValue("A", out var productA))
        {
            productA.Show();
        }

        if (FactoryDictionary.dict.TryGetValue("B", out var productB))
        {
            productB.Show();
        }
    }
}