关于委托的理解2

最新推荐文章于 2022-10-26 13:00:14 发布

挨踢啊挨踢

最新推荐文章于 2022-10-26 13:00:14 发布

阅读量558

点赞数

文章标签： object constructor components events null class

本文链接：https://blog.csdn.net/eastsun_genius/article/details/1500849

版权

摘自http://dev.poptool.net/wangluo/asp.net/csharp/9895.html

目录
导论
什么是委托
事件的理解
事件关键字
最后

导论

在学习C#中的委托和事件过程中，我读了许多文章来理解他们二者究竟是怎么一回事，以及如何使用他们，
现在我将整个的理解过程陈述以下，我学到的每一方面，恐怕也是你们需要掌握的：-）。

什么是委托？

委托和事件这两个概念是完全配合的。委托仅仅是函数指针，那就是说，它能够引用函数，通过传递地址的机制完成。委托是一个类，
当你对它实例化时，要提供一个引用函数，将其作为它构造函数的参数。
每一个委托都有自己的签名，例如：Delegate int SomeDelegate(string s, boolb);是一个委托申明，在这里，提及的签名，就是说SomeDelegate 这个委托有 string 和 bool 类型的形参，返回一个int 类型。

上面提及的：当你对委托实例化时，要提供一个引用函数，将其作为它构造函数的参数。这里要注意了：被引用的这个函数必须和委托
有相同的签名。

看下面的函数：

private int SomeFunction(string str, bool bln){...}

你可以把这个函数传给SomeDelegate的构造函数，因为他们有相似的签名（in other words，他们都有相同的形参类型和个数，并且返回相同的数据类型）。
SomeDelegate sd = new SomeDelegate(SomeFunction);
sd 引用了 SomeFunction，也就是说，SomeFunction已被sd所登记注册，如果你调用 sd，SomeFunction
这个函数也会被调用，记住：我所说 SomeFunction的含义，后面，我们会用到它。
现在，你应该知道如何使用委托了，让我们继续理解事件之旅……

事件的理解

我们知道，在C#中：

1. 按钮（Button）就是一个类，当我们单击它时，就触发一次click事件。
2. 时钟（Timer）也是一个类，每过一毫秒，就触发一次tick事件。

让我们通过一个例子来学习，假定有这样的情节：

现在有一个Counter的类，它有一个方法 CountTo(int countTo, int reachableNum)，该方法表示：在指定的时间段内（0~~countTo），当到达指定的时间点reachableNum时，就触发一次NumberReached事件。
它还有一个事件：NumberReached，事件是委托类型的变量。意思是：如果给事件命名，用event关键字和要使用的委托类型申明它即可
，如下所示：

public event NumberReachedEventHandler NumberReached;

在上面的申明中，NumberReachedEventHandle仅是一个委托，更确切的表示应该是：NumberReachedDelegate。但是微软从不这样认为MouseDelegate或者PaintDelegate，，而是称谓：M
ouseEventHandler 或者 PaintEventHandler。所以NumberReachedEventHandler比NumberReachedDelegate听起来更方便一些，OK?好了，让我们继续，现在你知道了，在我们声明事件之前，需要象下面这样的形式来
定义委托：

public delegate void NumberReachedEventHandler(object sender, NumberReachedEventArgs e);

现在声明的委托 NumberReachedEventHandle，它有一个void返回值，和object，NumberReachedEventArgs两个形参。就像我们在第一节中强调的那样，当实例化委托时，作为实参传入的函数也必须
拥有和委托同样的签名。在你的代码中，你是否用过PaintEventArgs 或者 MouseEventArgs来确定鼠标的移动位置？是否在触发Paint事件的对象中用过Graphics
属性？实际上，为用户提供数据的类都是继承于System.EventArgs类，就是我们常说的事件参数类，如果事件不提供参数，就不定义该类
。在我们的例子中，我们通过下面的类提供预期的时间点。

public class NumberReachedEventArgs : EventArgs
{
    private int _reached;
    public NumberReachedEventArgs(int num)
    {
        this._reached = num;
    }
    public int ReachedNumber
    {
        get
        {
            return _reached;
        }
    }
}
好，有了前面的介绍，让我们到Counter类里面看看：
namespace Events
{
   public delegate void NumberReachedEventHandler(object sender, NumberReachedEventArgs e);
    /// <summary>
    /// Summary description for Counter.
    /// </summary>
    public class Counter
    {
        public event NumberReachedEventHandler NumberReached;
        public Counter()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        public void CountTo(int countTo, int reachableNum)
        {
            if(countTo < reachableNum)
                throw new ArgumentException( "reachableNum should be less than countTo");
            for(int ctr=0;ctr<=countTo;ctr++)
            {
                if(ctr == reachableNum)
                {
                    NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum);
                    OnNumberReached(e);
                    return;   //don't count any more
                }
            }
        }

        protected virtual void OnNumberReached(NumberReachedEventArgs e)
        {
            if(NumberReached != null)
            {
                NumberReached(this, e);    //Raise the event
            }
        }
}

在Counter中，如果到达指定的时间点，就触发一次事件，有以下几个方面需要注意：

1. 通过调用NumberReached（它是NumberReachedEventHandler委托的实例）来完成一次触发事件。
NumberReached(this, e); 通过这种方式，可以调用所有的注册函数。
2. 通过 NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum); 为所有的注册函数提供事件数据。
3. 看了上面的代码，你可能要问了：为什么我们直接用 OnNumberReached(NumberReachedEventArgs e)方法来调用NumberReached（this，e），
而不用下面的代码呢？
if(ctr == reachableNum)
{
    NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum);
    //OnNumberReached(e);
    if(NumberReached != null)
    {
        NumberReached(this, e);//Raise the event
    }
    return; //don't count any more
}

这个问题问得很好，那就让我们再看一下OnNumberReached 签名：
protected virtual void OnNumberReached(NumberReachedEventArgs e)

①你也明白关键字protected限定了只有从该类继承的类才能调用该类中的所有方法。

②关键字 virtual 表明了在继承类中可以重写该方法。

这两点非常有用，假设你在写一个从Counter继承而来的类，通过重写OnNumberReached
方法，你可以在事件触发之前，进行一次其他的工作。
protected override void OnNumberReached(NumberReachedEventArgs e)
{
//Do additional work
base.OnNumberReached(e);
}

注意：如果你没有调用base.OnNumberReached(e),
那么从不会触发这个事件！在你继承该类而想剔出它的一些其他事件时，使用该方式是非常有用的。
还要注意到：委托 NumberReachedEventHandler 是在类定义的外部，命名空间内定义的，对所有类来说是可见的。
好，该我们来实际操作使用Counter类了。
在我们简单的应用程序中，我们有两个文本框，分别是：txtCountTo和txtReachable：
下面是btnRun的click事件：
private void btnRun_Click(object sender, System.EventArgs e)
{

           if(txtCountTo.Text == "" || txtReachable.Text=="")
              return;
           oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text));
       }
private void oCounter_NumberReached(object sender, NumberReachedEventArgs e)
       {
           MessageBox.Show("Reached: " + e.ReachedNumber.ToString());
    }

初始化事件处理的语法如下：

oCounter = new Counter();
oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);

现在你明白了你刚才所做的一切，仅仅初始化 NumberReachedEventHandler 委托类型的对象（就像你实例化其他对象一样），注意到
oCounter_NumberReached 方法的签名与我前面提到的相似。

还要注意我们用的是+= 而不是=；这是因为委托是特殊的对象，它可以引用多个对象（在这里是指它可以引用多个函数）。For example
如果有另外一个和oCounter_NumberReached一样具有相同签名的函数oCounter_NumberReached2，这两个函数都可以被引用：

oCounter = new Counter();

oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);

oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached2);

现在，触发一个事件后，上面两个函数被依次调用。

视情况而定，如果你想让oCounter_NumberReached2在NumberReached事件发生后不再被调用，可以简单地这样写：
oCounter.NumberReached-= new NumberReachedEventHandler(oCounter_NumberReached2);

最后
让我们看一下完整的源代码,以供参考：修正原文章源代码中cmdRun-->btnRun
//from1.cs
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace Events
{
/** <summary>
/// Summary description for Form1.
/// </summary>
public class Form1 : System.Windows.Forms.Form
{
  Counter oCounter = null;
  private System.Windows.Forms.TextBox txtReachable;
  private System.Windows.Forms.TextBox txtCountTo;
  private System.Windows.Forms.Label label1;
  private System.Windows.Forms.Label label2;
  private System.Windows.Forms.Button btnRemoveDelegate;
  private System.Windows.Forms.Button btnRun;
  /** <summary>
  /// Required designer variable.
  /// </summary>
  private System.ComponentModel.Container components = null;

  public Form1()
  {
   //
   // Required for Windows Form Designer support
   //
   InitializeComponent();

   //
   // TODO: Add any constructor code after InitializeComponent call
   //
   oCounter = new Counter();
   oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);
   oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached2);
  }

  /** <summary>
  /// Clean up any resources being used.
  /// </summary>
  protected override void Dispose( bool disposing )
  {
   if( disposing )
   {
    if (components != null)
    {
     components.Dispose();
    }
   }
   base.Dispose( disposing );
  }

  #region Windows Form Designer generated code#region Windows Form Designer generated code
  /** <summary>
  /// Required method for Designer support - do not modify
  /// the contents of this method with the code editor.
  /// </summary>
  private void InitializeComponent()
  {
   this.btnRun = new System.Windows.Forms.Button();
   this.txtReachable = new System.Windows.Forms.TextBox();
   this.txtCountTo = new System.Windows.Forms.TextBox();
   this.label1 = new System.Windows.Forms.Label();
   this.label2 = new System.Windows.Forms.Label();
   this.btnRemoveDelegate = new System.Windows.Forms.Button();
   this.SuspendLayout();
   //
   // btnRun
   //
   this.btnRun.Location = new System.Drawing.Point(16, 72);
   this.btnRun.Name = "btnRun";
   this.btnRun.Size = new System.Drawing.Size(48, 23);
   this.btnRun.TabIndex = 2;
   this.btnRun.Text = "Run";
   this.btnRun.Click += new System.EventHandler(this.btnRun_Click);
   //
   // txtReachable
   //
   this.txtReachable.Location = new System.Drawing.Point(144, 40);
   this.txtReachable.Name = "txtReachable";
   this.txtReachable.Size = new System.Drawing.Size(56, 20);
   this.txtReachable.TabIndex = 1;
   this.txtReachable.Text = "";
   //
   // txtCountTo
   //
   this.txtCountTo.Location = new System.Drawing.Point(144, 16);
   this.txtCountTo.Name = "txtCountTo";
   this.txtCountTo.Size = new System.Drawing.Size(56, 20);
   this.txtCountTo.TabIndex = 0;
   this.txtCountTo.Text = "";
   //
   // label1
   //
   this.label1.AutoSize = true;
   this.label1.Location = new System.Drawing.Point(16, 16);
   this.label1.Name = "label1";
   this.label1.Size = new System.Drawing.Size(51, 16);
   this.label1.TabIndex = 3;
   this.label1.Text = "Count To";
   //
   // label2
   //
   this.label2.AutoSize = true;
   this.label2.Location = new System.Drawing.Point(16, 40);
   this.label2.Name = "label2";
   this.label2.Size = new System.Drawing.Size(99, 16);
   this.label2.TabIndex = 4;
   this.label2.Text = "Reach this number";
   //
   // btnRemoveDelegate
   //
   this.btnRemoveDelegate.Location = new System.Drawing.Point(16, 104);
   this.btnRemoveDelegate.Name = "btnRemoveDelegate";
   this.btnRemoveDelegate.Size = new System.Drawing.Size(168, 23);
   this.btnRemoveDelegate.TabIndex = 5;
   this.btnRemoveDelegate.Text = "Remove second handler";
   this.btnRemoveDelegate.Click += new System.EventHandler(this.btnRemoveDelegate_Click);
   //
   // Form1
   //
   this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
   this.ClientSize = new System.Drawing.Size(224, 134);
   this.Controls.Add(this.btnRemoveDelegate);
   this.Controls.Add(this.label2);
   this.Controls.Add(this.label1);
   this.Controls.Add(this.txtCountTo);
   this.Controls.Add(this.txtReachable);
   this.Controls.Add(this.btnRun);
   this.Name = "Form1";
   this.Text = "Events";
   this.ResumeLayout(false);

}
#endregion

  /** <summary>
  /// The main entry point for the application.
  /// </summary>
  [STAThread]
  static void Main()
  {
   Application.Run(new Form1());
  }

  private void btnRun_Click(object sender, System.EventArgs e)
  {
   if(txtCountTo.Text == "" || txtReachable.Text=="")
    return;
   oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text));
  }

  private void oCounter_NumberReached(object sender, NumberReachedEventArgs e)
  {
   MessageBox.Show("Reached: " + e.ReachedNumber.ToString());
  }
  private void oCounter_NumberReached2(object sender, NumberReachedEventArgs e)
  {
   MessageBox.Show("Reached2: " + e.ReachedNumber.ToString());
  }

  private void btnRemoveDelegate_Click(object sender, System.EventArgs e)
  {
   oCounter.NumberReached -= new NumberReachedEventHandler(oCounter_NumberReached2);
   oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text));
  }

}
}

//Counter.cs

using System;

namespace Events
{
public delegate void NumberReachedEventHandler(object sender, NumberReachedEventArgs e);

/** <summary>
/// Summary description for Counter.
/// </summary>
public class Counter
{
  public event NumberReachedEventHandler NumberReached;

  public Counter()
  {
   //
   // TODO: Add constructor logic here
   //
  }
  public void CountTo(int countTo, int reachableNum)
  {
   if(countTo < reachableNum)
    throw new ArgumentException("reachableNum should be less than countTo");
   for(int ctr=0;ctr<=countTo;ctr++)
   {
    if(ctr == reachableNum)
    {
     NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum);
     OnNumberReached(e);
     return;//don@#t count any more
    }
   }
  }

  protected virtual void OnNumberReached(NumberReachedEventArgs e)
  {
   if(NumberReached!=null)
   {
    NumberReached(this, e);
   }
  }
}

挨踢啊挨踢

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于委托的理解2

摘自http://dev.poptool.net/wangluo/asp.net/csharp/9895.html目录导论什么是委托事件的理解事件关键字最后导论在学习C#中的委托和事件过程中，我读了许多文章来理解他们二者究竟是怎么一回事，以及如何使用他们，现在我将整个的理解过程陈述以下，我学到的每一方面，恐怕也是你们需要掌握的：-）。什么是委托？委托和事件这两个
复制链接

扫一扫