什么时候使用代理 - delegation

 

http://hi.baidu.com/luminji/blog/item/558323d98072492b11df9b9f.html

当我们要调用某个方法，但是我们只知道这个方法该长什么样子而不知道具体从哪里获得的时候，就是使用委托的时候。  

From envykok: e.g.: 异步调用, 你不知道什么时候会发生，什么时候会返回信息，或者事件，你不知道什么时候用户点击按钮

所以实际的项目通常都是1)定义委托，2)定义委托变量，3)让别人对委托变量赋值，4)把委托变量看成是个方法来调用。参考下面的代码

Employee wang = new Employee();

        public Form3()

        {

            InitializeComponent();

            //3：让别人（这里就是类的实例wang）订阅事件（也就是对委托变量赋值）。

            //取消订阅只需要将上面的 +=   改成 -=

            wang._varEvent += new Employee.PlayGameEventHandler(wang_PlayGame);

        }

 

        private void button1_Click(object sender, EventArgs e)

        {

            wang.PlayingGame("other str", "CS");

        }

 

        //这个就是事件处理器，也就是Employee类委托类的实例wang，生成了本函数来做出行为。

        void wang_PlayGame(string gameName)

        {

            MessageBox.Show("i am wang: " + gameName + "!!");

        }

 

        class Employee

        {

            //1：定义委托。委托不一定必须要用VOID，参数也可将实例本身传入，如下

            //public delegate void PlayGameEventHandler(Employee starter, string gameName);

            //一般定义委托的格式为

            //public   delegate   void   委托类型名(参数列表);

            public delegate void PlayGameEventHandler(string gameName);

 

            //2：定义事件，即“委托变量”——多播委托变量

           public event PlayGameEventHandler _varEvent;

 

            //订阅者，也就是Employee的实例必须首先要调用本函数，才能触发调用者本身的事件处理器

            //也就是本Employee类定义了一个函数PlayingGame，本函数却委托本类的实例去产生一个

            //事件处理器来做具体的事情。

            public void PlayingGame(string strEg, string gameName)

            {

                //调用订阅者的事件处理器

                if (this._varEvent != null)

                {

                    //4：把委托变量看成是个方法来调用（这是由语法结构决定的）

                    this._varEvent(strEg + gameName);

                }

            }

    }

     .NET里，有两个地方最常使用委托，首先就是事件，然后就是异步调用方法。上文描述的就是事件中的委托，最简单的事件委托。通过上面的例子，稍加修改，就可以实现类似这样的功能：类的属性发生了变化，自动调用外部实例的事件处理器等。

异步调用的例子如下：

public Form4()

        {

            InitializeComponent();

        }

        public delegate int AddHandler(int a, int b);

        static int Add(int a, int b)

        {

            Thread.Sleep(2000);

            return a + b;

        }

        static void AddComplete(IAsyncResult result)

        {

            AddHandler handler = (AddHandler)((AsyncResult)result).AsyncDelegate;

            MessageBox.Show(handler.EndInvoke(result).ToString());

            MessageBox.Show(result.AsyncState.ToString());

        }

        /// <summary>

        /// 这是同步调用

        /// </summary>

        /// <param name="sender"></param>

       /// <param name="e"></param>

        private void button1_Click(object sender, EventArgs e)

        {

            AddHandler handler = new AddHandler(Add);

            int result = handler.Invoke(1, 2);

            MessageBox.Show("" + result);

        }

 

        private void button2_Click(object sender, EventArgs e)

        {

            AddHandler handler = new AddHandler(Add);

            IAsyncResult result = handler.BeginInvoke(1, 2, new AsyncCallback(AddComplete), handler);

            //result.AsyncWaitHandle.WaitOne(9000,false);

        }

 

 

http://hi.baidu.com/luminji/blog/item/90ae5f17c17098064b90a728.html

C#事件委托妙文（转）

有许多人问的，.Net中的委托以及事件处理。我拿简单的例子说明一下，是现实中的例子：

比如说一个公司（场景），你是老板，手下有两个员工，小张和小王。
你命令小王，如果小张玩游戏，则小王扣去小张500元钱。

这就是现实中的委托。

实际上，在写程序中，程序员就是老板，小张和小王就是两个对象。小张玩游戏是一个方法，小张还有一个游戏事件，他玩游戏激发这个事件。而小王就是事件处理对象，他负责把小张的钱扣除500。

所以，委托有如下几个要素：
1 激发事件的对象--就是小张
2 处理对象事件的对象--就是小王
3 定义委托，就是你让小王监视小张。

如果这三个要素都满足的话，则你就写出了一个完整事件的处理。

下面有个例子：在vs.net2003 C#控制台应用程序编辑运行成功：
using System;

namespace CSharpConsole
{
public class 场景
{
   [STAThread]
   public static void Main(string[] args)
   {
    Console.WriteLine("场景开始了....");
    // 生成小王
    小王 w = new 小王();
    // 生成小账
    小张 z = new 小张();

    // 指定监视
    z.PlayGame += new PlayGameHandler(w.扣钱);

    // 开始玩游戏
    z.玩游戏();

    console.writeline("场景结束...");
    Console.ReadLine();
   }
}

// 负责扣钱的人
public class 小王
{
   public 小王()
   {
    Console.WriteLine("生成小王...");
   }

   public void 扣钱(object sender,EventArgs e)
   {
    Console.WriteLine("小王：好小子，上班时间胆敢玩游戏...");
    Console.WriteLine("小王：看看你小子有多少钱...");
    小张 f = (小张)sender;
    Console.WriteLine("小张的钱： " + f.钱.ToString());
    Console.WriteLine("开始扣钱......");
    System.Threading.Thread.Sleep(500);
    f.钱 = f.钱 - 500;
    Console.WriteLine("扣完了....现在小张还剩下：" + f.钱.ToString());
   }
}

// 如果玩游戏，则引发事件
public class 小张
{
   // 先定义一个事件，这个事件表示“小张”在玩游戏。
   public event PlayGameHandler PlayGame;
   // 保存小张钱的变量
   private int m_Money;

   public 小张()
   {
    Console.WriteLine("生成小张....");
    m_Money = 1000; // 构造函数，初始化小张的钱。
   }

   public int 钱 // 此属性可以操作小张的钱。
   {
    get
    {
     return m_Money;
    }
    set
    {
     m_Money = value;
    }
   }

   public void 玩游戏()
   {
    Console.WriteLine("小张开始玩游戏了.....");
    Console.WriteLine("小张:CS好玩，哈哈哈！ 我玩.....");
    System.Threading.Thread.Sleep(500);
    System.EventArgs e = new EventArgs();
    OnPlayGame(e);
   }

   protected virtual void OnPlayGame(EventArgs e)
   {
    if(PlayGame != null)
    {
     PlayGame(this,e);
    }
   }
}

// 定义委托处理程序
public delegate void PlayGameHandler(object sender,System.EventArgs e);

}

事件是委托的一个实例。

《C# 程序员参考手册》：C#使用一种委托模型来实现事件。事件的处理方法不必在将生成事件的类中定义。这种机制有许多优势。例如，它既有普遍性，又很灵活。设 想应用程序中有两个按钮，但这两个按钮的作用不同。如果事件处理程序被绑定到事件源，我们可能必须写两个派生的按钮类，每个派生类有自己的事件处理程序。

……事件生成者把事件委托的一个实例定义为它的成员。事件消费者是那些希望在事件发生时得到通知的对象。它们定义将和事件委托关联的事件处理方法。当生成事件时，事件生成者通过调用事件委托“触发”事件。然后委托调用和它关联的事件处理方法。