【C#设计模式-抽象工厂模式】

素颜马尾好姑娘i 2022-08-21 05:53 171阅读 0赞

### 一.抽象工厂模式的定义： ###

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

### 二.抽象工厂模式的结构: ###

![20160512115619717][]

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。

抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

应用场景：一个生产集团，在北京的工厂需要生产A类汽车，A类电视；在上海的工厂需要生产B类汽车，A类电视。而在广州的工厂需要生产C类汽车，C类电视。

我们可以使用抽象工厂，抽象出工厂类，和产品类，然后继承工厂类，生产所需要的具体产品类型，产品继承抽象出来的产品，实现里面的行为方法。

**1.我们抽象出Car产品和TV产品：**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ProductEntity
    {
        /// <summary>
        /// 抽象汽车产品
        /// </summary>
        public abstract class Car
        {
            public abstract void Build();
        }
    }

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ProductEntity
    {
        /// <summary>
        /// 抽象TV产品
        /// </summary>
        public abstract class TV
        {
            public abstract void work();
        }
    }

2.继承自抽象出来的产品类，实现里面的方法，成为具体产品：这里只举例Acar和TVA的，后面的Bcar,Ccar，TVB,TVC,类似。

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ProductEntity
    {
        public class CarA:Car    
        {
            public override void Build()
            {
                Console.WriteLine("CarA");
            }
        }
    }

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ProductEntity
    {
        public class TVA : TV
        {
            public override void work()
            {
                Console.WriteLine("TVA");
            }
        }
    }

3.抽象出工厂类，里面有待实现创建产品的方法：

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using ProductEntity;
    
    namespace FactoryMeth
    {
        /// <summary>
        /// 抽象生产工厂
        /// </summary>
        public abstract class AbstractFactory
        {
    
            /// <summary>
            /// 生产TV产品
            /// </summary>
            /// <returns></returns>
            public abstract TV newTV();
    
            /// <summary>
            /// 生产Car类产品
            /// </summary>
            /// <returns></returns>
            public abstract Car newCar();
        }
    }

4.创建具体的工厂类，继承自抽象出来的工厂，实现里面创建具体产品的方法。例：后面的B工厂，和C工厂类似实现。

using ProductEntity;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FactoryMeth
    {
        /// <summary>
        /// A工厂
        /// </summary>
        public class AbstractFactoryA:AbstractFactory
        {
            /// <summary>
            /// 生产A品牌电视
            /// </summary>
            /// <returns></returns>
            public override TV newTV()
            {
                return new TVA();
            }
    
            /// <summary>
            /// 生产A品牌汽车
            /// </summary>
            /// <returns></returns>
            public override Car newCar()
            {
                return new CarA();  
            } 
        }
    }

using ProductEntity;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FactoryMeth
    {
        /// <summary>
        /// B工厂生
        /// </summary>
        public class AbstractFactoryB:AbstractFactory
        {
            /// <summary>
            /// 生产B品牌电视
            /// </summary>
            /// <returns></returns>
            public override TV newTV()
            {
                return new TVB();
            }
    
            /// <summary>
            /// 生产A品牌汽车
            /// </summary>
            /// <returns></returns>
            public override Car newCar()
            {
                return new CarA();
            }
        }
    }

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using ProductEntity;
    namespace FactoryMeth
    {
        public class AbstractFactoryC:AbstractFactory
        {
            /// <summary>
            /// 生产C品牌电视
            /// </summary>
            /// <returns></returns>
            public override TV newTV()
            {
                return new TVC();
            }
    
            /// <summary>
            /// 生产C品牌汽车
            /// </summary>
            /// <returns></returns>
            public override Car newCar()
            {
                return new CarC();
            }
        }
    }

5.调用，根据具体情况进行选择，现在是在哪一个工厂，就创建该工厂：

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using FactoryMeth;
    using ProductEntity;
    
    namespace 抽象工厂模式
    {    
        class Program
        {
            static void Main(string[] args)
            {
                AbstractFactory factorysubA = new AbstractFactoryA();
                TV t = factorysubA.newTV();
                Car c = factorysubA.newCar();
                Console.WriteLine("A工厂生产：");
                t.work();
                c.Build();
    
                AbstractFactory factorysubB = new AbstractFactoryB();
                t = factorysubB.newTV();
                c = factorysubB.newCar();
                Console.WriteLine("B工厂生产：");
                t.work();
                c.Build();
    
                AbstractFactory factorysunC = new AbstractFactoryC();
                t = factorysunC.newTV();
                c = factorysunC.newCar();
                Console.WriteLine("C工厂生产：");
                t.work();
                c.Build();
                Console.Read();
            }
        }
    }

总结：以后如果该集团需要增加新的工厂，制造其他类型的产品，就只需要增加具体工厂类，和产品类，并实现具体产品即可。

**其实工厂和抽象工厂没有多大区别，只不过是抽象工厂生产的商品是多个而已  
通俗的说，就是抽象工厂模式的具体工厂里面会有多个实例具体对象的方法  
更直观的就是，抽象工厂模式每个工厂一次造多个产品,而工厂模式的每个工厂只造一个产品**

**![20160420132319042][]**

[20160512115619717]: /images/20220724/c316ecf3f29f4081af9eae5be040a316.png
[20160420132319042]: /images/20220724/74564c1bd94041f390196254ab20485c.png