C# 反射策略模式改造 switch case 或者 if else

最新推荐文章于 2024-06-13 16:15:19 发布

原创最新推荐文章于 2024-06-13 16:15:19 发布 · 2.7k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#C# 策略模式 #C# 设计模式 #C# 反射创建对象 #C# 策略模式代码 #C# 策略模式上下文

设计模式专栏收录该内容

1 篇文章

订阅专栏

本文深入讲解策略模式的应用，包括如何将策略模式应用于业务处理中，替代传统的switch-case或if-else结构，以实现代码的扩展性和灵活性。文章详细介绍了策略模式的实现方式，从简单的策略模式到引入上下文的策略模式，再到利用反射创建策略对象，提供了丰富的代码示例。

一、前言

由于在业务处理上使用了较多的 switch case 或者 if else，使用了策略模式改造下代码，以便后续的扩展，

但不应为了设计模式而设计模式，应从具体业务出发，不然只会让代码的复杂度增加

二、何为策略模式

也叫政策模式（Policy Pattern）。指的是对象具备某个行为，但是在不同的场景中，该行为有不同的实现算法。比如一个人的交税比率与他的工资有关，不同的工资水平对应不同的税率。

策略模式使用的就是面向对象的继承和多态机制，从而实现同一行为在不同场景下具备不同实现。

策略模式本质：分离算法，选择实现

三、应用策略模式

1）直白写法

public void DoWork(int taskType)
        {
            switch (taskType)
            {
                case (int)TaskType.上传单价:
                    Console.WriteLine("执行上传单价业务");
                    break;
                case (int)TaskType.上传工单:
                    Console.WriteLine("执行上传工单业务");
                    break;
                case (int)TaskType.上传配件:
                    Console.WriteLine("执行上传配件业务");
                    break;
                case (int)TaskType.上传附件:
                    Console.WriteLine("执行上传附件业务");
                    break;
                default:
                    Console.WriteLine("无效任务类型");
                    break;
            }
        }

2）简单策略模式

截取自 http://my.oschina.net/BreathL/blog/52655

2.1）创建策略接口类

/// <summary>
    /// 策略类接口
    /// </summary>
    public interface IStrategy
    {
        void DoStrategyWork();
    }

2.2）创建策略实现类

public class 上传单价 : IStrategy
    {
        public void DoStrategyWork()
        {
            Console.WriteLine("执行上传单价业务");
        }
    }

2.3）创建对外调用类

public class User
    {
        public void StartHere(IStrategy strategy)
        {
            strategy.DoStrategyWork();
        }
    }

2.4）调用

new 一般策略写法.User().StartHere(new InstanceFactory<一般策略写法.IStrategy>().CreateInstanceByEnumName(tType));

3）上下文的引入

上下层调用、交互，往往不是固定不变的，比如调用函数的参数变化、增加方法等

3.1）创建策略抽象类(接口也是可以的，具体业务具体分析)

/// <summary>
    /// 策略类抽象类
    /// </summary>
    public abstract class IStrategy
    {
        public abstract TaskType CommandType { get; }

        public abstract void DoStrategyWork(StrategyContext strategyContext);
    }

3.2）创建策略实现类

public class 上传单价 : IStrategy
    {
        public override TaskType CommandType => TaskType.上传单价;

        public override void DoStrategyWork(StrategyContext strategyContext)
        {
            Console.Write("执行上传单价业务 ");
            Console.WriteLine("我是可变参数：" + strategyContext.pars);
        }
    }

3.3）创建上下文类

通过上下文进行对应策略算法调用，执行具体实现类的算法，同时写携带业务交互参数

public class StrategyContext
    {
        private IStrategy _strategy;

        #region 可变的上下文参数

        public string pars { get; set; }

        #endregion

        public StrategyContext(IStrategy strategy)
        {
            this._strategy = strategy;
        }

        public void InvokingStrategy()
        {
            this._strategy.DoStrategyWork(this);
        }
    }

3.4）创建对外调用类

public class User
    {
        private StrategyContext strategyContext;

        public User(TaskType taskType, string pars)
        {
            this.strategyContext = new StrategyContext(new InstanceFactory<IStrategy>().CreateInstanceBySubClass(taskType));
            this.strategyContext.pars = pars;
        }

        public void StartHere()
        {
            strategyContext.InvokingStrategy();
        }
    }

3.5）调用

new 上下文策略写法.User(tType, "我是参数").StartHere();

四、反射创建对象

/// <summary>
    /// 利用反射创建具体策略类，并缓存起来
    /// </summary>
    public class InstanceFactory<T> where T : class
    {
        /// <summary>
        /// 一般处理对象缓存
        /// </summary>
        private static Dictionary<TaskType, T> dicCommands = new Dictionary<TaskType, T>();

        /// <summary>
        /// 上下文策略对象缓存
        /// </summary>
        private static Dictionary<TaskType, T> dicContextCommands = new Dictionary<TaskType, T>();
        
        /// <summary>
        /// 根据TaskType 的名称创建类对象
        /// </summary>
        /// <param name="taskType"></param>
        /// <returns></returns>
        public T CreateInstanceByEnumName(TaskType taskType)
        {
            foreach (TaskType cd in Enum.GetValues(typeof(TaskType)))
            {
                if (!dicCommands.Keys.Contains(cd))
                {
                    //(基类)Assembly.Load("当前程序集名称").CreateInstance("命名空间.子类名称"));  
                    T baseCommand = Assembly.Load(typeof(T).Assembly.GetName().Name)
                        .CreateInstance((typeof(T).Namespace + "." + cd)) as T;

                    if (baseCommand != null)
                    {
                        dicCommands.Add(cd, baseCommand);
                    }
                }

            }

            return dicCommands.FirstOrDefault(c => c.Key == taskType).Value;
        }

        /// <summary>
        /// 通过继承关系创建子类
        /// </summary>
        /// <param name="taskType"></param>
        /// <returns></returns>
        public T CreateInstanceBySubClass(TaskType taskType)
        {
            Type objType = typeof(T);
            // 获取此类型所在的程序集
            Assembly assembly = objType.Assembly;
            // 遍历获取此程序集中所有的类
            foreach (Type t in assembly.GetTypes())
            {
                // 是类并且不是抽象类并且继承IBaseCommand
                if (t.IsClass && !t.IsAbstract && t.IsSubclassOf(objType))
                {
                    // 创建策略实例类
                    T command = Activator.CreateInstance(t) as T;

                    var key = (TaskType)Enum.Parse(typeof(TaskType), t.GetProperty("CommandType").DeclaringType.Name);

                    if (command != null && !dicCommands.ContainsKey(key))
                    {
                        dicContextCommands.Add(key, command);
                    }
                }
            }

            return dicContextCommands.FirstOrDefault(c => c.Key == taskType).Value;
        }
    }