C# 策略模式

1 实现策略模式

1. 使用接口实现的代码

 /// <summary>
    /// 飞的接口
    /// </summary>
    public interface IFlyBehavior
    {
        string Fly();
        //  string Bark();
    }

    /// <summary>
    /// 火箭飞行实现
    /// </summary>
    public class FlyRocketPowered : IFlyBehavior
    {
        public string Fly()
        {
            return "以火箭的速度起飞";
        }
    }

    public class FlyNowWay : IFlyBehavior
    {
        public string Fly()
        {
            return "不会飞";
        }
    }

    public class Duck
    {
        public IFlyBehavior flyBehavior;
        public void setFlyBehavior(IFlyBehavior fb)
        {
            this.flyBehavior = fb;
        }
        public string performFly()
        {
            return flyBehavior.Fly();
        }
        //public Duck()
        //{
        //    flyBehavior = new FlyNowWay();
        //}
    }

    public class ModelDuck : Duck
    {
        public ModelDuck()
        {
           flyBehavior = new FlyNowWay();
        }
    }

2. 使用抽象类实现的代码

public abstract class StratageRun
    {
        public abstract string run();
        // public abstract string bark();
    }
    /// <summary>
    /// 算法A，不会跑
    /// </summary>
    public class RunNoWay : StratageRun
    {
        public override string run()
        {
            return "不会跑";
        }
    }
    /// <summary>
    /// 算法B，会跑
    /// </summary>
    public class RunRocketPowered : StratageRun
    {
        public override string run()
        {
            return "以火箭的速度跑出去了";
        }
    }

    /// <summary>
    /// 使用抽象类来实现策略模式
    /// </summary>
    public class Dog
    {
        public StratageRun stratageRun;
        public void SetRunBehavior(StratageRun sr)
        {
            this.stratageRun = sr;
        }
        public string performaceRun()
        {
            return stratageRun.run();
        }
    }
    /// <summary>
    /// 模型狗
    /// </summary>
    public class ModelDog : Dog
    {
        public ModelDog()
        {
            stratageRun = new RunNoWay();
        }
    }

3. 调用以及打印的结果

• 调用:

 			// 使用的接口的形式设计的策略模式
            ModelDuck modelDuck = new ModelDuck();
            Console.WriteLine(modelDuck.performFly());
            modelDuck.setFlyBehavior(new FlyRocketPowered());
            Console.WriteLine(modelDuck.performFly());

            // 使用抽象类的形式设计的策略模式
            ModelDog modelDog = new ModelDog();
            Console.WriteLine(modelDog.performaceRun());
            modelDog.SetRunBehavior(new RunRocketPowered());
            Console.WriteLine(modelDog.performaceRun());


            Console.ReadLine();

• 打印结果

不会飞
以火箭的速度起飞
不会跑
以火箭的速度跑出去了

• 分析
  在C#中使用抽象类或者接口来实现策略模式使用的方法和效果是一摸一样的。没有区别。
• 使用策略模式的好处 //ModelDuck（模型鸭）、RubberDuck（橡皮鸭）
  a.基类Duck下的子类 MallardDuck（绿头鸭）、ReadheadDuck（红头鸭）均继承Duck下的方法 void Fly(){ console.write(‘我可以飞啊飞’); }；，但是当需要添加子类RubberDuck（橡皮鸭）的时候，RubberDuck继承来的Fly方法就显得不合适。此时使用策略模式就非常好，只要重写Duck中的Fly方法，使其默认为会飞，不会飞的子类只要在构造函数中重新赋值不同的策略就可以了，完全不影响原来写好的其他子类。还实现了 策略算法的分离。

2 抽象类与接口（转载）

原文链接：https://blog.csdn.net/gdfjhc/article/details/84001589

以下是我在网上看到的几个形象比喻,真的非常不错,呵呵:
1.飞机会飞，鸟会飞，他们都继承了同一个接口“飞”；但是F22属于飞机抽象类，鸽子属于鸟抽象类。
2. 就像铁门木门都是门（抽象类），你想要个门我给不了（不能实例化），但我可以给你个具体的铁门或木门（多态）；而且只能是门，你不能说它是窗（单继承）；一个门可以有锁（接口）也可以有门铃（多实现）。 门（抽象类）定义了你是什么，接口（锁）规定了你能做什么（一个接口最好只能做一件事，你不能要求锁也能发出声音吧（接口污染））。

综上

使用接口方式实现策略模式应该更加事宜，毕竟策略属于能力。还有可能一个动作（比如上文中 ）