设计模式种类很多，但是目的确实一个，减少耦合，让代码的逻辑变的简单（也就是单一职责原则），同时在观察者模式种，有一种更好的方式，就是用委托来取代观察者模式，其实他也是一种非常好的去除If的方法。那么接下来咱们慢慢的说为什么，怎么实现的。

设计模式

状态模式

现在很多人都用手机了，那么大家几乎每个月都要交话费，大家也都接收到过10086给咱们的信息，说余额不足10元，余额不足3元，和欠费的情况。那么如果大家要编写这么要给程序，如果大家要用IF语句的话，大概应该是这个样子的。

	Public class MoneyState:State {
		Public void NotEnough(Double Moeny) {
			If Money<100.00 then {
				Console.WriteLine（”您的余额不足100元”）;
				QueryMoneyNow（）    //查询当前余额
<span style="white-space:pre">				</span>else If Money<100.00 then {
				Console.WriteLine（”您的余额不足100元”）;
<span style="white-space:pre">			</span><pre name="code" class="csharp"><span style="white-space:pre">				</span>QueryMoneyNow（）    //查询当前余额

Else if…
…… end if }
} }

可是这样的代码是可怕的，因为如果我要添加一个99元的，你就要从一堆IF语句种，找这个值应该的位置，而且还很容易破坏了原有的代码，这样是不符合开放闭合原则的。所以我们就迎来了状态模式。

状态模式是把if语句中的值（余额）的每一种状态单独的封装成一个类，这样，我们只需要要给Context管理一下用户的状态（余额），这样就能非常方便的把余额的信息告诉给用户，当然代码，大家可以看大话设计，这里我就不在贴那么多的代码了。

职责链模式

类似于状态模式，例如大家需要给某个大学，或者一个公司开发一个系统，现在有这么一个需求，员工需要提交一个申请，但是员工不知道具体再哪个级别能帮他完成这个审批，所以他就只能给他的上一级，上一级解决不了，就交给再上一级，这样一直往上走，直到有权限的人帮忙解决了。那么如果不考虑设计模式，思路应该是和上边的一样。if  有权限 then  同意

else 我解决不了，给我的上级

if 上级解决不了。

else 我解决不了，给我的上级

if 上级解决不了。

else 我解决不了，给我的上级

这家伙，再政府机关的话，这个流程可就长了，所以我们就得想办法解决了，如何解决的，利用状态模式的思想，把每个if...else封装起来，如果我能解决，就解决，不能，转给上级，这就是我的职能，然后上级同样。这样就可以保证这个职责能够顺利的完成，还能让我们的代码看起来好看很多。

委托

个人感觉委托就是一个特殊的类，他的功能就像是要给监视器，监视着定义的类的一切的行为（方法），并且告诉放置他的人，放置他的人只需要直接直接写下方法就可以了。

例如我们需要调用几个类里边的方法，以前我们的实现都是New要给类，然后点出来里边的方法，这样就会给内存添加负担，而且如果有一些判断的话，就会增加一些IF来判断，但是如果用委托的话，我们就会把上边的监视器放在类里边，用那个类的方法，直接就能点出来，这样说也许大家有点迷茫，看下边的代码。

不用委托

<span style="font-family:KaiTi_GB2312;font-size:18px;">namespace NoDelegate

{
    class Program

    {
        //加法运算
        public static int AddOpen(int a, int b)
        {
            return a + b;
        }

        //减法运算
        public static int SubOpen(int a, int b)
        {
            return a - b;
        }

        public enum Operate
        {
           Add, Sub
        }

        //结果
        public static int PeopleResult(int a, int b, Operate oper)
        {
            int result = 0;

            switch(oper)
            {
               case Operate.Add:
                   result = AddOpen(a, b);
                   break;
               case Operate.Sub:
                   result = SubOpen(a, b);
                   break;
            }
            return result;
        }

        static void Main(string[] args)
        {
            Console.WriteLine("最终相加结果是：" + PeopleResult(4,3,Operate.Add));
            Console.WriteLine("最终相减结果是：" + PeopleResult(4,3,Operate.Sub));
            Console.Read();
        }
    }
}
</span>

用委托

namespace Delegate
{
//定义委托
   public delegate int GenericFun(int a,int b);
    class Program
    {
        //加法运算
        public static int AddOpen(int a, int b)
        {
            return a + b;
        }
        //减法运算
        public static int SubOpen(int a, int b)
        {
            return a - b;
        }

        //结果
        public static int PeopleResult(GenericFun action, int a, int b)
        {
            int result = action(a, b);
            return result;
        }

        static void Main(string[] args)
        {
            Console.WriteLine("最终相加结果是：" + PeopleResult(AddOpen, 4, 3));
            Console.WriteLine("最终相减结果是：" + PeopleResult(SubOpen, 4, 3));
            Console.Read();
        }
    }
}

看出来了吗，用委托监视方法，就好像是一个代理模式一样，把别人的东西当成自己的来用。

当然减少IF语句的方法还有工作流，只是才刚刚接触，还没有弄透，但是会在下周为大家讲一下工作流（WorkFlow）。

师哥以前说过，第一遍可以是面向过程，但是绝不能止步于第一次，就像我们上边的代码，如果我们出现了多个IF语句，是不是就该想想，我们平时怎么解决if语句泛滥的问题，从而想办法解决这个泛滥问题。