标签：
Code1:
1 private delegate void BloodNumDelegate ();
2
3 public delegate void ExpNumChangeDelegate (int _currentExpNum);
4
5 public event ExpNumChangeDelegate mOnExpNumChangeDelegate;
Code2:
PlayerVoProxy.instance.mOnExpNumChangeDelegate += delegate(int _expNum)
{
Console.WriteLine ("阿呆收到, ExpNum is : {0}", _expNum);
};
如果你可以很清楚明白上面两部分代码是什么意思,说明你已经很了解Delegate(至少比我了解:) ),
所以我想下面的文章也许对你的帮助不是很大. 不过如果某些地方你也有所疑惑,希望你能从我下面的文章中得到一些帮助.
这篇文章从最基本的Delegate开始介绍起,后续会引申到event, 匿名Delegate 及我个人对其使用的一点理解
提前需要阅读的文章
如果你像我当初一样对Delegate完全不理解,请先阅读
NET之美：.NET关键技术深入解析.NET之美：.NET关键技术深入解析 迷你书 中的 第3章 (C# 中的委托和事件).
(作者对Delegate理解的及其深入,我是比不上了 :( )
从观察者模式说起
观察者模式大家肯定都不陌生
using System;
using System.Collections;
namespace L1
{
public class FakeBloodChangeDelegate
{
public ArrayList mAllFakeDelegateListener;
public FakeBloodChangeDelegate ()
{
mAllFakeDelegateListener = new ArrayList ();
}
public void addListener (IFakeBloodNumChangeDelegateListener _listener)
{
mAllFakeDelegateListener.Add (_listener);
}
public void upldateListener ()
{
foreach (IFakeBloodNumChangeDelegateListener listener in mAllFakeDelegateListener)
{
listener.onBloodNumChange ();
}
}
}
}
using System;
namespace L1
{
public interface IFakeBloodNumChangeDelegateListener
{
void onBloodNumChange ();
}
}
using System;
namespace L1
{
public class Idiot : IFakeBloodNumChangeDelegateListener
{
public Idiot ()
{
}
public void onBloodNumChange ()
{
Console.WriteLine ("Idiot --> onBloodNumChange");
}
}
}
using System;
namespace L1
{
public class TestArea1
{
private FakeBloodChangeDelegate mFakeBloodChangeDelegate;
private Idiot mIdiot;
public TestArea1 ()
{
}
public void run ()
{
mFakeBloodChangeDelegate = new FakeBloodChangeDelegate ();
mIdiot = new Idiot ();
mFakeBloodChangeDelegate.addListener (mIdiot);
mFakeBloodChangeDelegate.upldateListener ();
}
}
}
这是一个比较标准的观察者, idiot是监听的人,当主体(FakeBloodChangeDelegate)发生变化时候调用 updateListener方法告诉所有监听对象
Ok, 接下来让我们稍微对这个FakeBloodChangeDelegate类进行一个简单的封装, 为其创建一个Player对象,Blood是Player的一部分
using System;
namespace L1
{
public class FakePlayerVoProxy
{
public FakeBloodChangeDelegate bloodNumChangeListner;
private int mCurrentBloodNum = 0;
public FakePlayerVoProxy ()
{
bloodNumChangeListner = new FakeBloodChangeDelegate ();
}
public void addPlayerBlood (int _addNum)
{
mCurrentBloodNum += _addNum;
bloodNumChangeListner.upldateListener ();
}
}
}
于是,主类中的调用及变为:
using System;
namespace L1
{
public class TestArea1
{
private FakePlayerVoProxy mPlayerVo;
private Idiot mIdiot;
public TestArea1 ()
{
}
public void run ()
{
mPlayerVo = new FakePlayerVoProxy ();
mIdiot = new Idiot ();
mPlayerVo.bloodNumChangeListner.addListener (mIdiot);
mPlayerVo.addPlayerBlood (10);
}
}
}
运行一下代码,会得到和上面一样的输出。 毕竟其实只是简单的对FakeBloodChangeDelegate进行一个封装,没有改变任何的代码。
如果上面的例子可以完全理解，就让我们往下继续
Delegate 就是一个类
这个其实是一个很重要的信息,在上面提到的那本迷你书里面已经说的非常清楚了. 我之所以把代码蹩脚的写成这个模样 其实也是为了说明这件事。
上面例子中的FakeBloodChangeDelegate,包括对应的Listener可以简化为一行代码
public delegate void BloodNumChangeDelegate ();
先抛开public不说, 后面用 delegate void BloodNumChangeDelegate(); 相当于就是告诉编辑器为你创建出 一个
FakeBloodChangeDelegate 和 IFakeBloodNumChangeDelegateListener (其实这块是不准确的表达,不过目前可以先不要细纠结到时是怎么回事,当看完后面的内容后 可以回头再去看 上面我提到的那本迷你书,里面讲的很详细)
using System;
namespace L1
{
public class FakePlayerVoProxy
{
public delegate void BloodNumChangeDelegate ();
public BloodNumChangeDelegate bloodNumChangeListner;
private int mCurrentBloodNum = 0;
public FakePlayerVoProxy ()
{
}
public void addPlayerBlood (int _addNum)
{
mCurrentBloodNum += _addNum;
bloodNumChangeListner ();
}
}
}
注意
public delegate void BloodNumChangeDelegate (); 这行表示创建了FakeBloodChangeDelegate 类其实和 FackPlayerVoProxy这里类没有任何关系,
完全可以单独建立一个文件,起名Apple,然后把这行放在那个Apple的类里面 不过根据这个类(Delegate)创建对象时候你就不能写
public BloodNumChangeDelegate bloodNumChangeListner;
而要写
public Apple.BloodNumChangeDelegate bloodNumChangeListner;
个人关于Delegate的一点理解
因为是写AS出身(ActionSprite),所以对于回调函数一点都不陌生,而Delegate就可以理解为C#中的回调函数,唯一会比较费解的会是
public delegate void BloodNumChangeDelegate ();
public BloodNumChangeDelegate bloodNumChangeListner;
这两行代码,这块的核心就是要理解 Delegate其实就是告诉编译器为你生成一个实现了观察者模式的类.
关于Delegate前面的Public修饰符
之前我在解释Delegate是怎么一回事时候,故意忽略掉了其前面的类修饰符 public. 这块其实还是很有文章的. 对于Delegate或者回归本质,对于观察者模式,最主要的三个函数应该是
addListener, removeListener, updateListener
而OO的思想就是 一定要封装 对于外部监听者 只应该能访问到 addListener, removeListener 而upldateListner 这个应该只有主类才可以做的事情.
让我们先退回到实现Delegate之前的例子上面,继续使用FakeBloodChangeDelegate ,
若要实现以上的需求,仅需要对应的将FakeBloodChangeDelegate改为private 并提供相应的public函数即可
using System;
namespace L1
{
public class FakePlayerVoProxy
{
private FakeBloodChangeDelegate mBloodNumChangeListner;
private int mCurrentBloodNum = 0;
public FakePlayerVoProxy ()
{
mBloodNumChangeListner = new FakeBloodChangeDelegate ();
}
public void addListener(IFakeBloodNumChangeDelegateListener _listener)
{
mBloodNumChangeListner.Add(_listener);
}
public void removeListener(IFakeBloodNumChangeDelegateListener _listener){//对应Remove代码}
public void addPlayerBlood (int _addNum)
{
mCurrentBloodNum += _addNum;
bloodNumChangeListner.upldateListener ();
}
}
}
这块应该很好理解吧? 所以呢如果使用Delegate去实现同样的操作及可以写成:
using System;
namespace L1
{
public class FakePlayerVoProxy
{
public delegate void BloodNumChangeDelegate ();
private BloodNumChangeDelegate bloodNumChangeListner;
private int mCurrentBloodNum = 0;
public FakePlayerVoProxy ()
{
}
public void addListener (?? _listener)
{
bloodNumChangeListner += _listener;
}
public void addPlayerBlood (int _addNum)
{
mCurrentBloodNum += _addNum;
bloodNumChangeListner ();
}
}
}
你会发现 在addListener这里 不知道该怎么写了(其实是可以写的,不过如果这块你都理解怎么写了也就不用再继续往下读啦 哈), 这个 _listener应该是什么类型呢?
使用Event关键字
在推荐的那本迷你书里面(什么?! 还没看...) 已经把这块说的非常明白了, 为了封装Delegate,对外仅提供add,remove 但是不提供
update方法, 但是如果不写成public 又没办法对外访问,所以及产生了 Event这个关键字
using System;
namespace L1
{
public class FakePlayerVoProxy
{
public delegate void BloodNumChangeDelegate ();
public event BloodNumChangeDelegate bloodNumChangeListner;
private int mCurrentBloodNum = 0;
public FakePlayerVoProxy ()
{
}
public void addPlayerBlood (int _addNum)
{
mCurrentBloodNum += _addNum;
bloodNumChangeListner ();
}
}
}
using System;
namespace L1
{
public class TestArea1
{
private FakePlayerVoProxy mPlayerVo;
private Idiot mIdiot;
public TestArea1 ()
{
}
public void run ()
{
mPlayerVo = new FakePlayerVoProxy ();
mIdiot = new Idiot ();
mPlayerVo.bloodNumChangeListner += mIdiot.onBloodNumChange;
mPlayerVo.addPlayerBlood (10);
}
}
}
如果在TestArea1中调用 mPlayerVo.bloodNumChangeListner ();
会收到
Error(14,14): Error CS0070: The event `L1.FakePlayerVoProxy.bloodNumChangeListner‘ can only appear on the left hand side of += or -= when used outside of the type `L1.FakePlayerVoProxy‘ (CS0070) (L1)
也就是说在类的外部是无法调用"updateListener" 这个方法了. 这样也就符合了OO得封装原则
结束语
到此, Delegate和Event的用法 我想大家应该有了一个初步的认识,后续只要在项目中多试几次 应该就能有很好的掌握吧
(其实我接触C#也才不到一周,所以能理解的也就到这里了,希望对大家有帮助.)
等等! Code2中的 代码是什么?
PlayerVoProxy.instance.mOnExpNumChangeDelegate += delegate(int _expNum)
{
Console.WriteLine ("阿呆收到, ExpNum is : {0}", _expNum);
};
其实这个代码 可以理解为匿名函数( 其实是匿名委托)
比如对于一个按钮
private void fun1()
{
dummyBtn.onClick+=fun2
}
private void fun2()
{
//Fun2Code
}
但是如果fun2的代码很简单 或者其他原因 也可以使用 匿名委托 也就是如上的写法
private void fun1()
{
dummyBtn.onClick+=delegate()
{
//Fun2Code
}
}
一般在按钮的处理以及Tween操作时候大多愿意这样去做,不过我个人还是不太爱使用匿名委托(As3中是匿名函数)这种方式做处理. 因人而异吧.
真的不能使用 private BloodNumChangeDelegate bloodNumChangeListner 么?
using System;
namespace L1
{
public class FakePlayerVoProxy
{
public delegate void BloodNumChangeDelegate ();
private BloodNumChangeDelegate bloodNumChangeListner;
private int mCurrentBloodNum = 0;
public FakePlayerVoProxy ()
{
}
public void addListener(BloodNumChangeDelegate _listener)
{
bloodNumChangeListner += _listener;
}
public void addPlayerBlood (int _addNum)
{
mCurrentBloodNum += _addNum;
bloodNumChangeListner ();
}
}
}
using System;
namespace L1
{
public class TestArea1
{
private FakePlayerVoProxy mPlayerVo;
private Idiot mIdiot;
public TestArea1 ()
{
}
public void run ()
{
mPlayerVo = new FakePlayerVoProxy ();
mIdiot = new Idiot ();
mPlayerVo.addListener (mIdiot.onBloodNumChange);
mPlayerVo.addPlayerBlood (10);
}
}
}
以上两段代码是可以编译过并且可以运行的, 这个是我突然看到匿名委托使用的是Delegate修饰符所想到的,不过我对这块理解的也不是很透 如果有人知道原因 麻烦也给我解释一下吧
相关的内容 也许和 温故而知新：Delegate,Action,Func,匿名方法,匿名委托,事件 这篇文章提到的内容有关.
That‘s All
Eran.
标签：
原文地址：http://www.cnblogs.com/eran/p/4250969.html
