设计模式--建造者模式（组合模式）

建造者模式

优点：
抽象产品
产品A类包含a1和a2两种具体的
产品B类包含b1和b2两种具体的
组合产品包含一个A产品和一个B产品
抽象建造工厂生产一个组合产品
工厂M生产a1和b1的组合产品
工厂N生产a2和b2的组合产品

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;
using System.Reflection;

namespace FactoryMothod
{
    //组合产品
    class Compose
    {
        private product partA;
        private ProductTwo partB;
        public product PartA
        {
            get { return partA; }
            set { partA = value; }
        }
        public ProductTwo PartB
        {
            get { return partB; }
            set { partB = value; }
        }

    }
    //抽象产品
    interface product
    {
        void MethodSame();
        void MethodDisplay();
    }
    //具体产品A
    class ConcreatemethodA: product
    {
        public void MethodSame()
        {
            Console.WriteLine("MethodSameA");
        }
        public void MethodDisplay()
        {
            Console.WriteLine("MethodDisplayA");
        }
    }
    //具体产品B
    class ConcreatemethodB : product
    {
        public void MethodSame()
        {
            Console.WriteLine("MethodSameB");
        }
        public void MethodDisplay()
        {
            Console.WriteLine("MethodDisplayB");
        }
    }
    //抽象方法二
    interface ProductTwo
    {
        void MethodDisplay();
    }
    //具体产品二A
    class ConcreatemethodAA : ProductTwo
    {
  
        public void MethodDisplay()
        {
            Console.WriteLine("ConcreatemethodAA");
        }
    }
    //具体产品二B
    class ConcreatemethodBB : ProductTwo
    {

        public void MethodDisplay()
        {
            Console.WriteLine("ConcreatemethodBB");
        }
    }

    //抽象建造
    abstract class Builder
    {
        protected Compose actor = new Compose();
        public abstract void GetProduct();
        public abstract void GetProductTwo();

        public Compose CreateActor()
        {
            return actor;
        }
    }
    //具体建造工厂A
    class ConcreateFactoryA: Builder
    {
        public override void GetProduct()
        {
            product product = null;          
            product = new ConcreatemethodA();
            actor.PartA = product;
        }
        public override void GetProductTwo()
        {
            ProductTwo product = null;
            product = new ConcreatemethodAA();
            actor.PartB = product;
        }
    }
    //具体建造工厂B
    class ConcreateFactoryB : Builder
    {
        public override void GetProduct()
        {
            product product = null;
            product = new ConcreatemethodB();
            actor.PartA = product;
        }
        public override void GetProductTwo()
        {
            ProductTwo product = null;
            product = new ConcreatemethodBB();
            actor.PartB = product;
        }
    }
   
    //建造控制器
    class ActorContorl
    {
        public Compose Construct(Builder bd)
        {
            Compose comp;
            bd.GetProduct();
            bd.GetProductTwo();
            comp = bd.CreateActor();
            return comp;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            
            Compose actor;
            Builder bd;
            //读取配置文件
            string FactoryName = ConfigurationManager.AppSettings["FactoryName"];
            //反射生成对象
            object   obj = Assembly.Load("FactoryMothod").CreateInstance(FactoryName);
            bd = obj as Builder;
            ActorContorl ac = new ActorContorl();
            actor= ac.Construct(bd);
            actor.PartA.MethodDisplay();
            actor.PartA.MethodSame();
            actor.PartB.MethodDisplay();    
            Console.ReadKey();
        }
    }
}

配置文件

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>

    <add key="FactoryName" value="FactoryMothod.ConcreateFactoryA"/>
    </appSettings>
    
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
    </startup>
</configuration>