策略模式

策略模式是我个人觉得很有用的模式，它有用的点就是在于：正常情况下按照对象方法传递的种类不同，那么我们触发的方法不同

按照正常写法，我们定义枚举，将枚举类型对应选择的方法写在类的内部，这样一旦出现新的一类，不但需要在枚举类型中修改增加，也需要在实现类中修改增加

 enum Myenum
    {
        QuickSort,
        ShellSort,
        MergeSort,
    }

    class Sort
    {
        #region ArrayList基本设置
        private ArrayList _arr = new ArrayList();
        public void Add(string str)
        {
            _arr.Add(str);
        }
        public void Remove(string arr)
        {
            _arr.Remove(arr);
        }
        public void ShowArrayList()
        {
            foreach (string item in _arr)
            {
                Console.WriteLine(item);
            }
        }
        #endregion

        public void SortList(Myenum en)
        {
            if(en==Myenum.QuickSort)
            {
                Console.WriteLine("执行QuickSort后序方法");
            }
            else if(en==Myenum.MergeSort)
            {
                Console.WriteLine("执行MergeSort后序方法");
            }
            else if(en==Myenum.ShellSort)
            {
                Console.WriteLine("执行ShellSort后序方法");
            }
        }
    }

如果我将枚举类型排序具体逻辑扯出来，变成中介，这样本类就可以实现了封装，以后再增加逻辑的时候 ，可以保持原中间不动，新增一个中介(面向接口编程实现)，但是枚举类型无法封装

   //暂时还是这三种枚举类型
    enum Myenum
    {
        QuickSort,
        ShellSort,
        MergeSort,
    }

 //增加一个中介者
    interface Center
    {
        void SortList(ArrayList arr);
    }

   //中介者具体实现类
   //这样即使Center1不可以再修改，那么我可以在新建一个类，在新建的类中实现我想要的逻辑
    class Center1 : Center
    {
        private Myenum _en;
        public Center1(Myenum en)
        {
            _en = en;
        }
        public void SortList(ArrayList arr)
        {
            if(_en== Myenum.QuickSort)
            {
                arr.Sort();
                Console.WriteLine("QuickSort排续方法");
            }
        }
    }

   //排序类，自此被封装
   class Sort
    {
        #region ArrayList基本设置
        private ArrayList _arr = new ArrayList();
        public void Add(string str)
        {
            _arr.Add(str);
        }
        public void Remove(string arr)
        {
            _arr.Remove(arr);
        }
        public void ShowArrayList()
        {
            foreach (string item in _arr)
            {
                Console.WriteLine(item);
            }
        }
        #endregion

        public void SortList(Center center)
        {
            center.SortList(_arr);
        }
    }

   static void Main(string[] args)
        {
            Sort sort = new 策略模式.Sort();
            sort.Add("ss"); sort.Add("dd"); sort.Add("aa"); sort.Add("tt");
            sort.SortList(new Center1(Myenum.QuickSort));
            sort.ShowArrayList();
            Console.ReadKey();
        }

如果将上方枚举的各个类型转变为中介的具体实现，这样如果以后有新增的方法逻辑，只需要为该类型定义一个类，即可完成，从而实现不修改任何地方达到解耦。这就是策略模式

  interface Center
    {
        void SortList(ArrayList arr);
    }

//具体实现类型
  class QuickSort : Center
    {
        public void SortList(ArrayList arr)
        {
            arr.Sort();
            Console.WriteLine("QuickSort后续方法");
        }
    }
    class ShellSort : Center
    {
        public void SortList(ArrayList arr)
        {
            arr.Sort();
            Console.WriteLine("ShellSort后续方法");
        }
    }

   //与上方相同，无变化的排序类，已经被封装了
    class Sort
    {
        #region ArrayList基本设置
        private ArrayList _arr = new ArrayList();
        public void Add(string str)
        {
            _arr.Add(str);
        }
        public void Remove(string arr)
        {
            _arr.Remove(arr);
        }
        public void ShowArrayList()
        {
            foreach (string item in _arr)
            {
                Console.WriteLine(item);
            }
        }
        #endregion

        public void SortList(Center center)
        {
            center.SortList(_arr);
        }
    }

static void Main(string[] args)
        {
            Sort sort = new 策略模式.Sort();
            sort.Add("ss"); sort.Add("dd"); sort.Add("aa"); sort.Add("tt");
            //sort.SortList(new Center1(Myenum.QuickSort));
            sort.SortList(new ShellSort());//换成了这个
            sort.ShowArrayList();
            Console.ReadKey();
        }