C#设计模式——抽象工厂模式（重点）

文章目录

项目地址
一、抽象工厂模式
- [1.1 特性](#1.1 特性)
- [1.2 使用反射获取特性标记的类](#1.2 使用反射获取特性标记的类)
- [1.3 完整代码](#1.3 完整代码)

项目地址

教程作者：
教程地址：

复制代码

代码仓库地址：

复制代码

所用到的框架和插件：

dbt
airflow

一、抽象工厂模式

工厂方法模式依然存在一个问题就是，一堆的 switch用来根据符号判断；if或者switch都是描述了一段关系，运算符和具体工厂对象的对应关系，如何直接根据符号就可以自动获取对应的类，并且自动创建实例呢？

1.1 特性

什么是特性？
通过Attribute特性，根据输入的符号，直接将符号+和cal = new Add();对应起来，特性类似于一个装饰器，装饰器装饰的类，就拥有了这个对应关系；
往往和反射一起结合使用

创建一个特性，用来描述运算符和具体类的关系

//①使用特性Attribute来标记类的作用
public class OperToFactoryAttribute : Attribute
{
public string Oper { get; }
public OperToFactoryAttribute(string oper)
{
this.Oper = oper;
}
}
使用创建好的特性去标记运算类

//②使用特性Attribute来标记类的作用
//2.通过子类实现加法的创建
[OperToFactoryAttribute("+")]
public class AddFactory : ICalFactory
{
public ICal GetCalculator()
{
return new Add();
}
}

至此，运算符和对应需要的类已经创建完成，程序运行后，当用户输入了符号，我们应该通过这个对应关系，就可以找到这个类，然后进行实例化，计算

1.2 使用反射获取特性标记的类

根据用户的操作符，返回一个对象，
通过字典来存储对应关系
通过反射获取所有的程序集
获取所有的类型
通过判断获取AddFactory,SubFactory,MulFactory,DivFactory，找到他们的共性，都是继承了ICalFactory接口，并且排除ICalFactory自己

1.3 完整代码

csharp 复制代码

using System.ComponentModel;
using System.Reflection;

public class program
{
    static void Main()
    {
        Console.WriteLine("输入number1：");
        double d1 = Convert.ToDouble(Console.ReadLine());

        Console.WriteLine("输入number2：");
        double d2 = Convert.ToDouble(Console.ReadLine());
        Console.WriteLine("输入运算符：");
        string op = Console.ReadLine();

        //13.执行反射里的构造函数，创建符号和类的对应关系的字典
        ReflectionFactory rf = new ReflectionFactory();
        //15.通过运算符来创建工厂
        ICalFactory calFactory = rf.CreateFactory(op);
        //16.通过具体的运算类来计算结果
        ICal calculator = calFactory.GetCalculator();
        double res = calculator.getResult(d1, d2);
        Console.WriteLine(res);

    }
}

//1.创建特性Attribute来标记类的作用
public class OperToFactoryAttribute : Attribute
{
    public string Oper { get; } 
    public OperToFactoryAttribute(string oper)
    {
        this.Oper = oper;
    }
}

//声明一个接口,先将创建对象的这个过程封装成抽象
public interface ICalFactory
{
    ICal GetCalculator();
}

//3.通过反射，程序运行后，获取特性标记的类，然后通过反射创建对象
public class ReflectionFactory
{
    //4.创建字典，存储符号和类的对应关系
    Dictionary<string, ICalFactory> dic = new Dictionary<string, ICalFactory>();
    //5.构造函数
    public ReflectionFactory()
    {
        //6.通过反射获取所有的程序集
        Assembly asm = Assembly.GetExecutingAssembly();
        //7.获取所有的类型
        Type[] types = asm.GetTypes();
        foreach (var type in types)
        {
            //8.通过判断获取AddFactory,SubFactory,MulFactory,DivFactory
            if (typeof(ICalFactory).IsAssignableFrom(type) && !type.IsInterface)
            {
                //9.获取特性
                OperToFactoryAttribute otfa = type.GetCustomAttribute<OperToFactoryAttribute>();
                //10.判断是否为空
                if (otfa != null)
                {
                    //11.将特性和类的对应关系存储到字典中,根据type创建对象
                    dic.Add(otfa.Oper, Activator.CreateInstance(type) as ICalFactory);
                }
            }
        }
    }

    //12.通过运算符来创建工厂
    public ICalFactory CreateFactory(string oper)
    {
        //13. 从字典里查找对应关系
        if (dic.ContainsKey(oper))
        {
            return dic[oper];
        }
        return null;
    }
}

//2.使用特性Attribute来标记类的作用
[OperToFactoryAttribute("+")]
public class AddFactory : ICalFactory
{
    public ICal GetCalculator()
    {
        return new Add();
    }
}

[OperToFactoryAttribute("-")]
public class SubFactory : ICalFactory
{
    public ICal GetCalculator()
    {
        return new Sub();
    }
}

[OperToFactoryAttribute("*")]
public class MulFactory : ICalFactory
{
    public ICal GetCalculator()
    {
        return new Mul();
    }
}

[OperToFactoryAttribute("/")]
public class DivFactory : ICalFactory
{
    public ICal GetCalculator()
    {
        return new Div();
    }
}

//计算类的接口
public interface ICal
{
    double getResult(double num1, double num2);
}


public class Add : ICal
{
    public double getResult(double num1, double num2)
    {
        return num1 + num2;
    }
}
public class Sub : ICal
{
    public double getResult(double num1, double num2)
    {
        return num1 - num2;
    }
}

public class Mul : ICal
{
    public double getResult(double num1, double num2)
    {
        return num1 * num2;
    }
}

public class Div : ICal
{
    public double getResult(double num1, double num2)
    {
        return num1 / num2;
    }
}