C#中的委托和游戏中的运用

C#中的委托与游戏中的运用

1.什么是委托

在C/C++中，有函数指针的概念，即指向函数的指针。当我们调用该指针时，就相当于调用了该指针所指向的函数，这就是函数指针的一个作用，而他另一个作用就是将自己作为其他函数的参数。

但是指针是直接访问内存单元的，程序员对指针的不恰当使用常常会引发错误。因此作为一门类型安全的语言，在一般情况下C# 是不推荐使用指针的，比如使用函数指针作为参数时，你可以使用任何指针作为参数，因为他们都是32位的整型变量，不提供任何其他的信息，比如函数的参数个数，参数类型，返回值等。因此，在C#中就有了委托的概念。

我们首先来看一个简单的委托实例：

using System;
using System.Collections.Generic;
using System.Text;

namespace DelegateTest
{
    class program
    {
        delegate void MyDelegateTest(int x);

        private static void test1(int x)
        {
            Console.WriteLine("输出平方" + (x * x));
        }

        private static void test2(int x)
        {
            Console.WriteLine("输出和" + (x + x));
        }

        static void Main(string[] args)
        {
            int a = ;
            MyDelegateTest delegateTest;
            delegateTest = new MyDelegateTest(test1);
            //delegateTest = test1;
            //delegateTest += test1;
            delegateTest += test2;
            delegateTest(a);
        }
    }
}

 

2.C#中委托的发展

上述是一个简单的委托例子，这里不再赘述具体的实现。基本来看委托和一个类的声明实现类似，首先以delegate关键字声明一个委托类型(这里注意声明的返回类型以及类型参数需要和后面对应的方法相同）；然后声明和实例化一个委托类型变量，最后调用该委托即可，注意添加到委托上的每个方法都会被调用,而我们并不关心这些方法是如何实现的。

在C#2.0之前，委托的定义都是通过上述步骤实现的，而在C#2.0中，引入了匿名方法的概念，其实就是简化了委托的写法。比如我们之前需要写：

delegateTest = new MyDelegateTest(test1);

现在就可以简化为：

delegateTest = delegate(int x){ return x * x;}

而在C#3.0中，又引入了函数式语言中的lambda表达式进一步简化：

delegateTest = x => {return x * x;} 或直接x =>x * x;

在C#4.0又有了泛型委托，其实就是定义的时候加个泛型限制：

delegateT MyDelegateTest<T>(T x);

 

3.通过委托实现观察者模式

    观察者模式是设计模式中一个很常见的模式，从生活中的例子来说，就是对发布者进行关注的订阅者，在订阅者有更新时，就会把消息推送给那些订阅者。在C# 中可以用委托来实现观察者模式：

using System;
using System.Collections.Generic;
using System.Text;

namespace ObserverModel
 {
      class Program
      {
          //------------------------------------------------------------------
          // 委托充当订阅者类
          public delegate void DelegateSender(object sender);

          //------------------------------------------------------------------
          // 发布者类
          public class Publisher
         {
             public DelegateSender SenderEvent;
             public string Info;
              //--------------------------------------------------------------------
             public Publisher(string info)
             {
                 this.Info = info;
             }

             //-----------------------------------------------------------------------
             //添加和删除订阅者
             public void AddObserver(DelegateSender ob)
             {
                 SenderEvent += ob;
             }
             public void RemoveObserver(DelegateSender ob)
             {
                 SenderEvent -= ob;
             }

             //----------------------------------------------------------------------
             //发布者更新
             public void Update()
             {
                 if (SenderEvent != null)
                 {
                     SenderEvent(this);
                 }
             }
         }

         //--------------------------------------------------------------------------
         // 具体订阅者类1
         public class Subscriber
         {
             public string Name;
             public Subscriber(string name)
             {
                 this.Name = name;
             }

             public void DoSomething(Object sender= null)
             {
                 Console.WriteLine("订阅者1的操作");
             }
         }
         //--------------------------------------------------------------------------
         //具体订阅者类2
         public class Subscriber2
         {
             public string Name;
             public Subscriber2(string name)
             {
                 this.Name = name;
             }

             public void DoSomething2(Object sender= null)
             {
                 Console.WriteLine("订阅者2的操作");
             }
         }

         static void Main(string[] args)
         {
             Publisher publisher = new Publisher("发布者");
             Subscriber sub1 =  new Subscriber("订阅者1");
             Subscriber2 sub2=  new Subscriber("订阅者2");

             // 添加订阅者
             publisher.AddObserver(new DelegateSender(sub1.DoSomething));
             publisher.AddObserver(new DelegateSender(sub2.DoSomething));
             publisher.Update();

             //移除订阅者
             publisher.RemoveObserver(new DelegateSender(sub1.DoSomething));
             publisher.Update();

             Console.ReadLine();
         }
     }
 }

　　

这里也讨论一下观察者模式的优缺点：

a.观察者模式在订阅者和发布者之间建立一个抽象的耦合。发布者只知道一个订阅者列表。抽象了具体的发布者和订阅者，减少了二者之间的耦合性；

b.观察者模式支持广播通讯。发布者回想所有登记的订阅者发出通知。

 

c.如果一个发布者有很多直接或间接的订阅者，将所有的订阅者通知到会花费一定的时间；

d.如果发布者和订阅者之间有依赖循环的话会导致系统崩溃；

e.订阅者虽然知道发布者发生了变化，但是不知道对方是如何发生变化的.

4.游戏中委托的使用

游戏中的一些消息机制就是通过委托来实现的，以游戏中属性变化为例，在界面的声明周期开始，我们调用：sysTem.AddUIListener(DgMsgID.NetRes_Profile, OnProfile);为我们的委托字典对应的键上添加一个响应方法；

在界面的生命周期结束时，我们调用：Messenger.RemoveListener(DgMsgID.NetRes_Profile, OnProfile);将我们的委托字典上对应键上的该方法移除。

当我们从服务器接收到的数据更新了角色属性时，则会广播该消息，调用委托字典上该键上所添加的所有方法：Messenger.Broadcast<PlayerProfile>(DgMsgID.DgMsg_UpDatePlayerProfile, response.profile);

而在Messenger类中上述方法的实现其实就是添加、伤处、调用委托字典上的对应键上添加的方法。

 

另外一个典型应用就是NGUI定义的UIEventListener类，该类中定义了很多自定义委托，用于处理UI的各种操作响应，如：

public delegate void VoidDelegate (GameObject go);
public delegate void BoolDelegate (GameObject go, bool state);

public UIEventListener.VoidDelegate onClick;
public UIEventListener.BoolDelegate onPress;

void OnClick (){ if (onClick != null) onClick(gameObject); }
void OnPress (bool isPressed){ if (onPress != null) onPress(gameObject, isPressed); }

使用时也很简单，如：

UIEventListener.Get(targetObj).onPress += onPressHandler;

　　

本文参考了：http://www.cnblogs.com/zhili/p/ObserverPattern.html 有关设计模式的文章，受益匪浅。