策略模式（Stategy Pattern）

 知识点

• 　　找出引用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
• 　　针对接口编程，而不是实现编程。
• 　　多用组合，少用继承

示例

 1     public interface FlyBehavior
 2     {
 3         void Fly();
 4     }
 5 
 6     class FlyWithWings:FlyBehavior
 7     {
 8         #region FlyBehavior 成员
 9 
10         public void Fly()
11         {
12             Console.WriteLine("会飞的鸭子");
13         }
14 
15         #endregion
16     }
17 
18    public class FlyNoWay:FlyBehavior
19     {
20         #region FlyBehavior 成员
21 
22         public void Fly()
23         {
24             Console.WriteLine("飞不起来的");
25         }
26 
27         #endregion
28     }

飞行行为

 1     public interface QuackBehavior
 2     {
 3         void Quack();
 4     }
 5 
 6     class Quack:QuackBehavior
 7     {
 8         #region QuackBehavior 成员
 9 
10         void QuackBehavior.Quack()
11         {
12             Console.WriteLine("嘎！嘎！嘎！");
13         }
14 
15         #endregion
16     }
17 
18     class MuteQuack:QuackBehavior
19     {
20         #region QuackBehavior 成员
21 
22         public void Quack()
23         {
24             Console.WriteLine("世界一片安静");
25         }
26 
27         #endregion
28     }

叫行为

 1     public abstract class Duck
 2     {
 3         //将鸭子的行为通过组合的方式使用，而不是继承
 4         FlyBehavior _flyBehavior;
 5         QuackBehavior _quackBehavior;
 6 
 7         public FlyBehavior FlyBehavior
 8         {
 9             set { _flyBehavior = value; }
10         }
11 
12         public QuackBehavior QuackBehavior
13         {
14             set { _quackBehavior = value; }
15         }
16 
17         public abstract void Display();
18 
19         public void PerformFly()
20         {
21             _flyBehavior.Fly();
22         }
23         public void PerformQuack()
24         {
25             _quackBehavior.Quack();
26         }
27     }

鸭子抽象类

1     class RedheadDuck:Duck
2     {
3         public override void Display()
4         {
5             Console.WriteLine("红头鸭");
6         }
7     }

实现类红头鸭

 1     class Program
 2     {
 3         static void Main(string[] args) {
 4             Duck duck = new RedheadDuck() { 
 5                 FlyBehavior=new FlyWithWings(),
 6                 QuackBehavior=new Quack()
 7             };
 8             duck.Display();
 9             duck.PerformFly();
10             duck.PerformQuack();
11 
12             Console.ReadKey();
13         }
14     }

定义

　　定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

小结

　　将主体类的行为分开放在别的类中，这个类就专门用来提供行为接口的实现，这样主体类就不再需要关注行为的实现细节。

　　就像上面的代码中，红头鸭的飞行为，放在了FlyWithWings类中，这个类实现了一个飞行为的接口，具体怎么飞，在红头鸭的类中我们不需要知道，只要交给FlyWithWings类就行。

转载于:https://www.cnblogs.com/liunlls/p/Strategy.html