抽象工厂模式优化

上一篇说的是简单工厂，工厂模式，抽象工厂

抽象工厂解决了我们切换的问题，但是如果要新增子类的时候，我们需要修改的地方就很多了

要新增一个类IProject,ProjectA,ProjectB,更改抽象工厂以及工厂的实现子类

没有一种方法是适用于所有情况的，也没有一种方法是万能的，不同的场景，我们要考虑不同的方法进行优化

在这里，我说的是用简单工厂模式优化抽象工厂，以应对新增的情况,先来简单工厂的图

好的，上代码

namespace AbstractFactoryOptimize
{
    /*抽象工厂在切换产品的时候很方便，但是在新增功能的时候，就会要改动很多东西了
     要新增一个类IProject,ProjectA,ProjectB,更改抽象工厂以及工厂的实现子类
     这时候，我们单单用抽象工厂是不便于扩展的，考虑用简单工厂应对这种场景
     */
    public abstract class Product
    {
        public abstract void work();
    }
    public class ProductA : Product
    {
        public override void work()
        {
            Console.Write("ProductA");
        }
    }
    public class ProductB : Product
    {
        public override void work()
        {
            Console.Write("ProductB");
        }
    }
    public abstract class Car
    {
        public abstract void  Build();
    }
    public class CarA : Car
    {
        public override void Build()
        {
            Console.Write("Build CarA");
        }
    }
    public class CarB : Car
    {
        public override void Build()
        {
            Console.Write("Build CarB");
        }
    }
    //简单工厂代替抽象工厂
    public class SimplyFactory
    {
        private static readonly string db = "A";
        //工厂生产多个对象
        public static Product newproduct()
        {
            Product product = null;
            switch (db)
            {
                case "A":
                    product = new ProductA();
                    break;
                case "B":
                    product = new ProductB();
                    break;
                default:
                    break;
            }
            return product;
        }

        public static Car newCar()
        {
            Car car = null;
            switch (db)
            {
                case "A":
                    car = new CarA();
                    break;
                case "B":
                    car = new CarB();
                    break;
                default:
                    break;
            }
            return car;
        }
    }

    //简单工厂改造抽象工厂之客户端
    public class AbstractFactoryClient
    {
        public static void GetFactoryMethod()
        {
            Product product = SimplyFactory.newproduct();
            product.work();

            Car car = SimplyFactory.newCar();
            car.Build();

            Console.Read();
        }
    }
}

改成这样之后，我们要进行切换，需要修改的是

  private static readonly string db = "A";

其他地方无需更改！

但是，我们还是需要修改代码，进行编译，然后才能生效，考虑用反射优化这种情况,上反射优化代码

namespace AbstractFactoryOptimize
{
    /*抽象工厂在切换产品的时候很方便，但是在新增功能的时候，就会要改动很多东西了
     要新增一个类IProject,ProjectA,ProjectB,更改抽象工厂以及工厂的实现子类
     这时候，我们单单用抽象工厂是不便于扩展的，考虑用简单工厂应对这种场景
     */
    public abstract class Product
    {
        public abstract void work();
    }
    public class ProductA : Product
    {
        public override void work()
        {
            Console.Write("ProductA");
        }
    }
    public class ProductB : Product
    {
        public override void work()
        {
            Console.Write("ProductB");
        }
    }
    public abstract class Car
    {
        public abstract void  Build();
    }
    public class CarA : Car
    {
        public override void Build()
        {
            Console.Write("Build CarA");
        }
    }
    public class CarB : Car
    {
        public override void Build()
        {
            Console.Write("Build CarB");
        }
    }

    //用反射的写法优化抽象工厂,xml文件对应子类名称，有改动的时候修改xml文件就可以了，不需要修改程序并编译
    public class Reflect
    {
        private static readonly string assambly = "AbstractFactoryOptimize";//程序集名称
        private static readonly string db = ConfigurationManager.AppSettings["a"];

        public static Product newproduct()
        {
            string name = assambly + "." + "Product" + db;//命名空间.类名
            return (Product) Assembly.Load(assambly).CreateInstance(name);
        }

        public static Car newcar()
        {
            string name = assambly + "." + "Car" + db;
            return (Car) Assembly.Load(assambly).CreateInstance(name);
        }
    }
public class reflextClient
{
            Product product = Reflect.newproduct();
            product.work();

            Car car = Reflect.newcar();
            car.Build();

            Console.Read();
}
}

xml文件中配置节点

 <appSettings>
    <add key ="a" value="B"/>
  
  </appSettings>

这样的话，如果有什么变化，我们修改xml文章中的配置就可以了

这也会带来一个问题，就是反射的程序集如果要卸载，我们只能通过停止当前进程达到目的，用Appdomain(应用程序域)可以解决