C#设计模式之AbstractFactory_抽象工厂_对象创建新模式-学习

cs 复制代码

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

namespace AbstractFactoryPattern
{
    // 抽象产品：按钮接口
    public interface IButton
    {
        void Render();
        string Click();
    }

    // 抽象产品：文本框接口
    public interface ITextBox
    {
        void Render();
        void SetText(string text);
        string GetText();
    }

    // 具体产品：Windows风格按钮
    public class WindowsButton : Button, IButton
    {
        public WindowsButton()
        {
            this.Text = "Windows Button";
            this.BackColor = Color.LightBlue;
            this.Size = new Size(150, 40);
            this.Font = new Font("Segoe UI", 10);
        }

        public void Render()
        {
            Console.WriteLine("渲染Windows风格按钮");
        }

        public string Click()
        {
            return "Windows按钮被点击";
        }
    }

    // 具体产品：Mac风格按钮
    public class MacButton : Button, IButton
    {
        public MacButton()
        {
            this.Text = "Mac Button";
            this.BackColor = Color.LightGreen;
            this.Size = new Size(150, 40);
            this.Font = new Font("Helvetica", 10);
            this.FlatStyle = FlatStyle.Flat;
        }

        public void Render()
        {
            Console.WriteLine("渲染Mac风格按钮");
        }

        public string Click()
        {
            return "Mac按钮被点击";
        }
    }

    // 具体产品：Linux风格按钮
    public class LinuxButton : Button, IButton
    {
        public LinuxButton()
        {
            this.Text = "Linux Button";
            this.BackColor = Color.LightSalmon;
            this.Size = new Size(150, 40);
            this.Font = new Font("Ubuntu", 10);
        }

        public void Render()
        {
            Console.WriteLine("渲染Linux风格按钮");
        }

        public string Click()
        {
            return "Linux按钮被点击";
        }
    }

    // 具体产品：Windows风格文本框
    public class WindowsTextBox : TextBox, ITextBox
    {
        public WindowsTextBox()
        {
            this.Text = "Windows TextBox";
            this.Size = new Size(200, 30);
            this.BackColor = Color.AliceBlue;
            this.Font = new Font("Segoe UI", 10);
        }

        public void Render()
        {
            Console.WriteLine("渲染Windows风格文本框");
        }

        public void SetText(string text)
        {
            this.Text = text;
        }

        public string GetText()
        {
            return this.Text;
        }
    }

    // 具体产品：Mac风格文本框
    public class MacTextBox : TextBox, ITextBox
    {
        public MacTextBox()
        {
            this.Text = "Mac TextBox";
            this.Size = new Size(200, 30);
            this.BackColor = Color.Honeydew;
            this.Font = new Font("Helvetica", 10);
            this.BorderStyle = BorderStyle.FixedSingle;
        }

        public void Render()
        {
            Console.WriteLine("渲染Mac风格文本框");
        }

        public void SetText(string text)
        {
            this.Text = text;
        }

        public string GetText()
        {
            return this.Text;
        }
    }

    // 具体产品：Linux风格文本框
    public class LinuxTextBox : TextBox, ITextBox
    {
        public LinuxTextBox()
        {
            this.Text = "Linux TextBox";
            this.Size = new Size(200, 30);
            this.BackColor = Color.MistyRose;
            this.Font = new Font("Ubuntu", 10);
        }

        public void Render()
        {
            Console.WriteLine("渲染Linux风格文本框");
        }

        public void SetText(string text)
        {
            this.Text = text;
        }

        public string GetText()
        {
            return this.Text;
        }
    }

    // 抽象工厂接口
    public interface IUIFactory
    {
        IButton CreateButton();
        ITextBox CreateTextBox();
        string GetOSStyle();
    }

    // 具体工厂：Windows UI工厂
    public class WindowsUIFactory : IUIFactory
    {
        public IButton CreateButton()
        {
            return new WindowsButton();
        }

        public ITextBox CreateTextBox()
        {
            return new WindowsTextBox();
        }

        public string GetOSStyle()
        {
            return "Windows风格";
        }
    }

    // 具体工厂：Mac UI工厂
    public class MacUIFactory : IUIFactory
    {
        public IButton CreateButton()
        {
            return new MacButton();
        }

        public ITextBox CreateTextBox()
        {
            return new MacTextBox();
        }

        public string GetOSStyle()
        {
            return "Mac风格";
        }
    }

    // 具体工厂：Linux UI工厂
    public class LinuxUIFactory : IUIFactory
    {
        public IButton CreateButton()
        {
            return new LinuxButton();
        }

        public ITextBox CreateTextBox()
        {
            return new LinuxTextBox();
        }

        public string GetOSStyle()
        {
            return "Linux风格";
        }
    }

    // 客户端代码
    public class UIApplication
    {
        private IUIFactory _factory;
        private IButton _button;
        private ITextBox _textBox;

        public UIApplication(IUIFactory factory)
        {
            _factory = factory;
            CreateUI();
        }

        private void CreateUI()
        {
            _button = _factory.CreateButton();
            _textBox = _factory.CreateTextBox();
            
            Console.WriteLine($"创建{_factory.GetOSStyle()}界面元素");
            _button.Render();
            _textBox.Render();
        }

        public string SimulateUserInteraction()
        {
            _textBox.SetText("用户输入文本");
            return $"{_button.Click()} -> 文本框内容: '{_textBox.GetText()}'";
        }

        public Control[] GetUIElements()
        {
            return new Control[] { (Control)_button, (Control)_textBox };
        }
    }

    // 演示窗体
    public class AbstractFactoryDemoForm : Form
    {
        private ComboBox _styleComboBox;
        private Button _applyButton;
        private Panel _uiPanel;
        private Label _resultLabel;
        
        private UIApplication _currentApp;

        public AbstractFactoryDemoForm()
        {
            this.Text = "抽象工厂模式演示";
            this.Size = new Size(600, 400);
            this.StartPosition = FormStartPosition.CenterScreen;
            
            InitializeComponents();
        }

        private void InitializeComponents()
        {
            // 样式选择
            _styleComboBox = new ComboBox
            {
                Location = new Point(20, 20),
                Size = new Size(150, 30),
                DropDownStyle = ComboBoxStyle.DropDownList
            };
            _styleComboBox.Items.AddRange(new object[] { "Windows", "Mac", "Linux" });
            _styleComboBox.SelectedIndex = 0;
            
            // 应用按钮
            _applyButton = new Button
            {
                Text = "应用风格",
                Location = new Point(190, 20),
                Size = new Size(100, 30),
                BackColor = Color.LightGray
            };
            _applyButton.Click += ApplyButton_Click;
            
            // 结果标签
            _resultLabel = new Label
            {
                Location = new Point(20, 300),
                Size = new Size(550, 40),
                BorderStyle = BorderStyle.FixedSingle
            };
            
            // UI面板
            _uiPanel = new Panel
            {
                Location = new Point(20, 70),
                Size = new Size(550, 200),
                BorderStyle = BorderStyle.FixedSingle,
                BackColor = Color.WhiteSmoke
            };
            
            this.Controls.Add(_styleComboBox);
            this.Controls.Add(_applyButton);
            this.Controls.Add(_uiPanel);
            this.Controls.Add(_resultLabel);
            
            // 初始创建
            ApplyStyle();
        }

        private void ApplyButton_Click(object sender, EventArgs e)
        {
            ApplyStyle();
        }

        private void ApplyStyle()
        {
            _uiPanel.Controls.Clear();
            
            IUIFactory factory = null;
            
            switch (_styleComboBox.SelectedItem.ToString())
            {
                case "Windows":
                    factory = new WindowsUIFactory();
                    break;
                case "Mac":
                    factory = new MacUIFactory();
                    break;
                case "Linux":
                    factory = new LinuxUIFactory();
                    break;
            }
            
            if (factory != null)
            {
                _currentApp = new UIApplication(factory);
                
                var controls = _currentApp.GetUIElements();
                controls[0].Location = new Point(50, 30);
                controls[1].Location = new Point(50, 100);
                
                _uiPanel.Controls.Add(controls[0]);
                _uiPanel.Controls.Add(controls[1]);
                
                // 添加按钮点击事件
                ((Button)controls[0]).Click += (s, e) => 
                {
                    _resultLabel.Text = _currentApp.SimulateUserInteraction();
                };
                
                _resultLabel.Text = $"已创建{factory.GetOSStyle()}界面";
            }
        }
    }

    public class A3_AbstractFactory_抽象工厂_对象创建新模式
    {
        public static void RunDemo()
        {
            Application.EnableVisualStyles();
            Application.Run(new AbstractFactoryDemoForm());
        }
    }
}

抽象工厂模式核心概念

模式结构

抽象产品 (Abstract Product)
- 定义产品对象的接口（如 IButton, ITextBox）
- 客户端代码通过抽象产品接口操作对象
具体产品 (Concrete Product)
- 实现抽象产品接口的具体类（如 WindowsButton, MacTextBox）
- 属于特定产品族的实现
抽象工厂 (Abstract Factory)
- 声明创建抽象产品对象的接口（IUIFactory）
- 包含一组创建不同产品的方法
具体工厂 (Concrete Factory)
- 实现抽象工厂接口（如 WindowsUIFactory）
- 创建属于特定产品族的具体产品

模式优点

产品一致性：确保创建的产品属于同一产品族（如所有Windows风格组件）
解耦客户端与具体类：客户端只与抽象接口交互
易于切换产品族：只需更改具体工厂即可切换整个产品系列
符合开闭原则：添加新产品族时无需修改现有代码

学习要点

产品族概念：一组相关或相互依赖的产品（如Windows风格按钮+文本框）
平台独立性：客户端代码不依赖于具体平台实现
创建过程封装：产品创建细节被封装在具体工厂中
可扩展性：添加新产品族容易（如添加Android风格）

使用场景

系统需要独立于产品的创建、组合和表示
系统需要配置多个产品系列中的一个
需要确保相关产品对象一起使用
需要提供产品类库，只暴露接口不暴露实现

模式对比

模式	特点
抽象工厂模式	创建多个产品族，强调产品系列一致性
工厂方法模式	创建单一产品，通过子类决定实例化
简单工厂模式	创建单一产品，集中决策逻辑