delegate使用以及event

最新推荐文章于 2023-01-08 22:57:02 发布

babylon_0049

最新推荐文章于 2023-01-08 22:57:02 发布

阅读量935

点赞数

文章标签： object string methods class button c#

C# 的 Delegate Type
Delegate 是一种函数指针，但与普通的函数指针相比，区别主要有三：
1) 一个 delegate object 一次可以搭载多个方法（methods）[译注1]，而不是一次一个。当我们唤起一个搭载了多个方法（methods）的 delegate，所有方法以其“被搭载到 delegate object 的顺序”被依次唤起——稍候我们就来看看如何这样做。
2) 一个 delegate object 所搭载的方法（methods）并不需要属于同一个类别。一个 delegate object 所搭载的所有方法（methods）必须具有相同的原型和形式。然而，这些方法（methods）可以即有 static 也有 non-static，可以由一个或多个不同类别的成员组成。
3) 一个 delegate type 的声明在本质上是创建了一个新的 subtype instance，该 subtype 派生自 .NET library framework 的 abstract base classes Delegate 或 MulticastDelegate，它们提供一组 public methods 用以询访 delegate object 或其搭载的方法（methods）
声明 Delegate Type
一个 delegate type 的声明一般由四部分组成：(a) 访问级别；(b) 关键字 delegate；(c)返回型别，以及该 delegate type 所搭载之方法的声明形式（signature）；(d) delegate type 的名称，被放置于返回型别和方法的声明形式（signature）之间。(以上摘自网上)
C#虽然取消了指针的这个概念,但还是可以使用指针的,只要声明这段代码是非安全的(Unsafe).C#为指针找到一个更为有用的引用类型----代表元,它在C#类型里是十分安全的.在声明代表元时,只要指定代表元指向的原型的类型,它不能有返回值,也不能带回输出类型的参数.代表元可以封装一个静态方法,也可以封装一个非静态方法.例子如下:

例1.

using System;

namespace Delegate1

{

public class MyClass

{

public int InstanceMethod(int a,int b)

{

Console.WriteLine("Call InstanceMethod ");

Console.WriteLine("First parametre is {0},second parametre is {1}", a, b);

return 0;

}

static public int StaticMethod()

{

Console.WriteLine("Call Static Method");

return 0 ;

}

class Class1

{

//声明的代表元要与将代表的方法的参数序列保持一致

private delegate int MyDelegate();

private delegate int MeDelegatePara(int a, int b);

[STAThread]

static void Main(string[] args)

{

MyClass p = new MyClass();

//将代表元指向静态方法 StaticMethod

MyDelegate D = new MyDelegate( MyClass.StaticMethod);

D();

//将代表元指向带参数的非静态方法 InstanceMethod

MeDelegatePara d = new MeDelegatePara( p.InstanceMethod );

d(1, 2);

}

例1的缺点在于每次使用代表元时都要进行实例化,如果能从类中获取代表元就方便了很多,解决方法是将代表元的声明放入到高一级的名字空间

中,或者将代表元封装到一个类中,然后在相关类中以属性的形式绑定静态代表.我推荐使用类封装的方式,下面是改进后的类结构.

using System;

namespace Delegate1

{

public class CDelegate

{

//声明的代表元与将代表的方法的参数的序列要保持一致

public delegate int MyDelegate();

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

}

public class MyClass

{

public int InstanceMethod(int a,int b)

{

Console.WriteLine("Call InstanceMethod ");

Console.WriteLine("First parametre is {0},second parametre is {1}", a, b);

return 0;

}

static public int StaticMethod()

{

Console.WriteLine("Call Static Method");

return 0 ;

}

public static CDelegate.MyDelegate MyDelegate1

{

get

{

return new CDelegate.MyDelegate(StaticMethod);

}

public CDelegate.MeDelegatePara MyDelegate2

{

get

{

return new CDelegate.MeDelegatePara(InstanceMethod);

}

class Class1

{

[STAThread]

static void Main(string[] args)

{

MyClass p = new MyClass();

//将代表元指向静态方法 StaticMethod

CDelegate.MyDelegate D = MyClass.MyDelegate1;

D();

//将代表元指向带参数的非静态方法 InstanceMethod

CDelegate.MeDelegatePara d = p.MyDelegate2 ;

d(1, 2);

}

-----------------------------------------------

代表（delegate）：

它是C#语言里面的函数指针，代表可以指向某一个函数，在运行的时候调用这个函数的实现。下面来看看它的实现步骤：

声明一个delegate对象。
实现和delegate具有相同参数和返回值的函数实现（可以是静态和非静态的）。
产生一个delegate对象的时候，把你刚刚实现的函数作为参数传给他的构造函数。

请看下面例子：

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

namespace UsingDelegate
{
public delegate void MyDelegate(string mydelegate);//声明一个delegate对象

public class TestClass
{

        //实现有相同参数和返回值的函数
        public void HelloDelegate(string mydelegate)
        {
            Console.WriteLine(mydelegate);
        }

//实现有相同参数和返回值的静态函数

        public static void HelloStaticDelegate(string mystaticdelegate)
        {
            Console.WriteLine(mystaticdelegate);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            TestClass testClass = new TestClass();
            MyDelegate mydelegate = new MyDelegate(testClass.HelloDelegate);//产生delegate对象
            mydelegate("Hello delegate");//调用

            MyDelegate myStaticDelegate = new MyDelegate(TestClass.HelloStaticDelegate);//产生delegate对象
            myStaticDelegate("Hello static delegate");//调用
        }
    }
}

事件（event）：

让我通过一个例子来模拟事件的整个过程：

创建一个button类，它里面有一个click 事件。
创建一个Form类，他里面有一个我们上面定义的button类。
要求：当我们用户单击button类的时候From类要对他进行处理，输出一条信息“我知道你被单击了”

请看下图：

首先我们会单击button，然后button会通知Form，然后From就作出相应。这个过程在C#里面应该怎么做到呢？

下面我会列出上述例子的源代码（这里就不介绍怎么声明event等等内容了）：

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

namespace UsingEvent
{
public delegate void ClickEventHandler(object sender, EventArgs e);//声明一个代表：请看文章最后面Note

    public class MyButton              //创建MyBottom
    {
        public event ClickEventHandler ClickEvent;//声明一个事件

        public void Click()                                 //单击MyButton
        {
            if (ClickEvent != null)
            {
                Console.WriteLine("MyButton: 我被单击了");
                ClickEvent(this, null);                          //抛出事件，给所有相应者
            }
        }
    }

    public class MyForm
    {
        public MyButton myButton = new MyButton();

public MyForm()
{

//添加事件到myButton中，当myButton被单击的时候就会调用相应的处理函数

myButton.ClickEvent += new ClickEventHandler(OnClickEvent);

}

//事件处理函数

       void OnClickEvent(object sender, EventArgs e)
        {
            Console.WriteLine("MyForm: 我知道你被单击了！");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyForm form = new MyForm();//生成一个MyForm

            form.myButton.Click();//单击MyForm中的鼠标，效果就出来了
        }
    }
}

Note：public delegate void ClickEventHandler(object sender, EventArgs e);这是事件委托标准的声明方法，其实在参数里面我们可以不传，也可以是其他类型的。但是最好还是使用上面的声明方法，你可以继承EventArgs，来包装你要传送的其他任何参数。

------------------------------------------------------------------------------

delegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它只能持有与它的签名相匹配的方法的引用。它所实现的功能与C/C++中的函数指针十分相似。它允许你传递一个类A的方法m给另一个类B的对象，使得类B的对象能够调用这个方法m。但与函数指针相比，delegate有许多函数指针不具备的优点。首先，函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：
1．声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。
2．创建delegate对象，并将你想要传递的函数作为参数传入。
3．在要实现异步调用的地方，通过上一步创建的对象来调用方法。using System;

public class MyDelegateTest
{
// 步骤1，声明delegate对象
public delegate void MyDelegate(string name);

        // 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型
        public static void MyDelegateFunc(string name)
        {
               Console.WriteLine("Hello, ", name);
        }
        public static void Main()
        {
               // 步骤2，创建delegate对象
               MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
               // 步骤3，调用delegate
               md("sam1111");
        }
}

输出结果是：Hello, sam1111

了解了delegate，下面我们来看看，在C#中对事件是如何处理的。
C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。
就是这么简单，结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：
1．定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
2．定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。
3．定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。
4．用event关键字定义事件对象，它同时也是一个delegate对象。
5．用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。
6．在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。
7．在适当的地方调用事件触发方法触发事件。
下面是一个简单的例子：

using System;
public class EventTest
{
       // 步骤1，定义delegate对象
       public delegate void MyEventHandler(object sender, System.EventArgs e);
       // 步骤2省略
       public class MyEventCls
       {
                // 步骤3，定义事件处理方法，它与delegate对象具有相同的参数和返回值类// 型
                public void MyEventFunc(object sender, System.EventArgs e)
                {
                      Console.WriteLine("My event is ok!");
                }
       }
       // 步骤4，用event关键字定义事件对象
      private event MyEventHandler myevent;
      private MyEventCls myecls;
      public EventTest()
      {
                myecls = new MyEventCls();
                // 步骤5，用+=操作符将事件添加到队列中
                this.myevent += new MyEventHandler(myecls.MyEventFunc);
      }
      // 步骤6，以调用delegate的方式写事件触发函数
     protected void OnMyEvent(System.EventArgs e)
      {
               if(myevent != null)
                       myevent(this, e);
      }
     public void RaiseEvent()
      {
               EventArgs e = new EventArgs();
               // 步骤7，触发事件
               OnMyEvent(e);
      }
      public static void Main()
      {
               EventTest et = new EventTest();
               Console.Write("Please input ''a'':");
               string s = Console.ReadLine();
               if(s == "a")
               {
                     et.RaiseEvent();
               }
               else
              {
                        Console.WriteLine("Error");
              }
      }
}

--------------------------------------------------------------

public delegate void EatEventHandler(object sender, EatEventArgs e);
这个的定义也可以不要这样.可以直接就定义一个参数
public delegate void EatEventHandler(string e); 但然用的时候的参数要相对应好哦

using System;

namespace nsEventSample
{
/// <summary>
/// 类EatEventArgs 必须继承自类EventArgs，用来引发事件时封装数据
/// </summary>
public class EatEventArgs : EventArgs
{
public String restrauntName; //饭店名称
public decimal moneyOut; //准备消费金额
}

/// <summary>
/// 这个委托用来说明处理吃饭事件的方法的方法头(模式)
/// </summary>
public delegate void EatEventHandler(object sender, EatEventArgs e);

/// <summary>
/// 引发吃饭事件(EateEvent)的类Master(主人)，这个类必须
/// 1.声明一个名为EatEvent的事件: public event EatEventHandler EatEvent;
/// 2.通过一个名为OnEatEvent的方法来引发吃饭事件，给那些处理此事件的方法传数据；
/// 3.说明在某种情形下引发事件呢？在饿的时候。用方法Hungrg来模拟。
/// </summary>
public class Master
{
//声明事件
public event EatEventHandler EatEvent;

//引发事件的方法
public void OnEatEvent(EatEventArgs e)
{
if (EatEvent != null)
{
EatEvent(this, e);
}
}

//当主人饿的时候，他会指定吃饭地点和消费金额。
public void Hungry(String restrauntName, decimal moneyOut)
{
EatEventArgs e = new EatEventArgs();
e.restrauntName = restrauntName;
e.moneyOut = moneyOut;

Console.WriteLine("主人说：");
Console.WriteLine("我饿了，要去{0}吃饭，消费{1}元", e.restrauntName, e.moneyOut);

//引发事件
OnEatEvent(e);
}
}

/// <summary>
/// 类Servant(仆人)有一个方法ArrangeFood(安排食物)来处理主人的吃饭事件
/// </summary>
public class Servant
{
public void ArrangeFood(object sender, EatEventArgs e)
{
Console.WriteLine();
Console.WriteLine("仆人说:");
Console.WriteLine("我的主人, 您的命令是 : ");
Console.WriteLine("吃饭地点 -- {0}", e.restrauntName);
Console.WriteLine("准备消费 -- {0}元 ", e.moneyOut);
Console.WriteLine("好的，正给您安排。。。。。。。。");
Console.WriteLine("主人，您的食物在这儿，请慢用");
}
}

/// <summary>
/// 类God安排qinshihuang（秦始皇）的仆人是lisi（李斯），并让李斯的ArrangeFood
/// 方法来处理qinshihuang的吃饭事件：qinshihuang.EatEvent += new EatEventHandler(lishi.ArrangeFood);
/// </summary>
public class God
{
public static void Main()
{
Master qinshihuang = new Master();
Servant lishi = new Servant();

qinshihuang.EatEvent += new EatEventHandler(lishi.ArrangeFood);

//秦始皇饿了，想去希尔顿大酒店，消费5000元
qinshihuang.Hungry("希尔顿大酒店", 5000.0m);
}
}
}

------------------------------------------------------------

比如说一个公司（场景），你是老板，手下有两个员工，小王和小张。你命令小王注意小张，在开发软件工作的时候如果上网打游戏，你就记录下来，从小张工资里扣100元钱。这个实际上就是现实中的委托。

现在给出一个代码，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);
}