设计模式实践-简单工厂

场景

每种仪表都实现了统一的接口，设计一个工厂，生产不同的仪表

实现代码

仪表接口：

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表接口
    /// </summary>
    public interface IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        void ShowType();
    }
}

仪表A实现：

using System;

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表类型A
    /// </summary>
    internal class MeterA : IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Type A");
        }
    }
}

仪表B实现：

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

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表类型B
    /// </summary>
    internal class MeterB : IMeter
    {
        /// <summary>
        /// 显示仪表类型
        /// </summary>
        public void ShowType()
        {
            Console.WriteLine("Type B");
        }
    }
}

工厂接口：

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 工厂接口
    /// </summary>
    public interface IMeterFactory
    {
        /// <summary>
        /// 生产仪表类型A
        /// </summary>
        /// <returns>仪表类型</returns>
        IMeter CreateMeterA();

        /// <summary>
        /// 生产仪表类型B
        /// </summary>
        /// <returns>仪表类型</returns>
        IMeter CreateMeterB();

        /// <summary>
        /// 根据需要的仪表类型生产仪表
        /// </summary>
        /// <param name="meterType">仪表类型</param>
        /// <returns>仪表对象</returns>
        IMeter CreateMeterByType(MeterType meterType);
    }
}

工厂实现：

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表工厂类
    /// </summary>
    public class MeterFactory : IMeterFactory
    {
        /// <summary>
        /// 生产类型A仪表
        /// </summary>
        /// <returns>类型A仪表</returns>
        public IMeter CreateMeterA()
        {
            return new MeterA();
        }

        /// <summary>
        /// 生产类型B仪表
        /// </summary>
        /// <returns>类型B仪表</returns>
        public IMeter CreateMeterB()
        {
            return new MeterB();
        }
    }
}

使用枚举类型生产仪表

仪表类型枚举：

namespace DesignPatterns.SimpleFactory
{
    /// <summary>
    /// 仪表类型枚举类
    /// </summary>
    public enum MeterType
    {
        /// <summary>
        /// 类型A 
        /// </summary>
        TypeA,

        /// <summary>
        /// 类型B 
        /// </summary>
        TypeB
    }
}

生产仪表方法：

......
        /// <summary>
        /// 根据需要的仪表类型生产仪表
        /// </summary>
        /// <param name="meterType">仪表类型</param>
        /// <returns>仪表对象</returns>
        public IMeter CreateMeterByType(MeterType meterType)
        {
            switch (meterType)
            {
                case MeterType.TypeA:
                    return new MeterA();
                case MeterType.TypeB:
                    return new MeterB();
                default:
                    return null;
            }
        }
......

静态工厂

静态工厂实现：

namespace DesignPatterns.SimpleFactory
{
    public static class StaticMeterFactory
    {
        public static IMeter CreateMeterA()
        {
            return new MeterA();
        }

        public static IMeter CreateMeterB()
        {
            return new MeterB();
        }

        public static IMeter CreateMeterByType(MeterType meterType)
        {
            switch (meterType)
            {
                case MeterType.TypeA:
                    return new MeterA();
                case MeterType.TypeB:
                    return new MeterB();
                default:
                    return null;
            }
        }
    }
}

相关调用

            IMeterFactory meterFactory = new MeterFactory();
            var meterA = meterFactory.CreateMeterA();
            var meterB = meterFactory.CreateMeterB();
            meterA.ShowType();
            meterB.ShowType();

            meterA = meterFactory.CreateMeterByType(MeterType.TypeA);
            meterB = meterFactory.CreateMeterByType(MeterType.TypeB);
            meterA.ShowType();
            meterB.ShowType();

            meterA = StaticMeterFactory.CreateMeterA();
            meterB = StaticMeterFactory.CreateMeterB();
            meterA.ShowType();
            meterB.ShowType();

Out：

Type A
Type B
Type A
Type B
Type A
Type B