abstractfactorystructural.cs

使用C#程序将23个常用设计模式进行列表显示

using System;
using System.Windows.Forms;
using System.Text;

//抽象工厂模式
//意图 
//    提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
//适用性
//    一个系统要独立于它的产品的创建、组合和表示时。
//    一个系统要由多个产品系列中的一个来配置时。
//    当你要强调一系列相关的产品对象的设计以便进行联合使用时。
//    当你提供一个产品类库，而只想显示它们的接口而不是实现时。

namespace DesignPattern.AbstractFactoryStructural
{
    class AbstractFactoryStructural : AbstractPattern
    {
        public static void Run(TextBox tbInfo)
        {
            s_tbInfo = tbInfo;
            s_tbInfo.Text = "";

            // Abstract factory #1 
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1); 
            c1.Run(); 
            
            // Abstract factory #2 
            AbstractFactory factory2 = new ConcreteFactory2(); 
            Client c2 = new Client(factory2);
            c2.Run(); 
            
            // Wait for user input 
            ////Console.Read();
        }
    }

    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    // "ConcreteFactory1" 
    class ConcreteFactory1 : AbstractFactory 
    {
        public override AbstractProductA CreateProductA() 
        {
            return new ProductA1();
        }
        
        public override AbstractProductB CreateProductB() 
        {
            return new ProductB1();
        }
    }
    
    // "ConcreteFactory2" 
    class ConcreteFactory2 : AbstractFactory 
    {
        public override AbstractProductA CreateProductA()
        { 
            return new ProductA2(); 
        }
        public override AbstractProductB CreateProductB() 
        {
            return new ProductB2();
        }
    }
    
    // "AbstractProductA" 
    abstract class AbstractProductA 
    {

    }
    
    // "AbstractProductB" 
    abstract class AbstractProductB 
    {
        public abstract void Interact(AbstractProductA a); 
    }

    class ProductA1 : AbstractProductA 
    {
    }
    
    // "ProductB1" 
    class ProductB1 : AbstractProductB 
    {
        public override void Interact(AbstractProductA a) 
        {
            DesignPattern.FormMain.OutputInfo(this.GetType().Name + " interacts with " + a.GetType().Name + " in ProductB1"); 
        }
    }
    
    // "ProductA2" 
    class ProductA2 : AbstractProductA 
    {
    }
    
    // "ProductB2" 
    class ProductB2 : AbstractProductB 
    { 
        public override void Interact(AbstractProductA a) 
        {
            DesignPattern.FormMain.OutputInfo(this.GetType().Name + " interacts with " + a.GetType().Name + " ProductB2"); 
        }
    }
    
    // "Client" - the interaction environment of the products 
    class Client 
    {
        private AbstractProductA AbstractProductA; 
        private AbstractProductB AbstractProductB; 

        // Constructor 
        public Client(AbstractFactory factory) 
        {
            AbstractProductA = factory.CreateProductA();
            AbstractProductB = factory.CreateProductB();
        }
        
        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }
}