C#编程之委托与事件四（一）【转】

C#编程之委托与事件(一)

本文试图在.net Framework环境下，使用C#语言来描述委托、事件的概貌。希望本文能有助于大家理解委托、事件的概念，理解委托、事件的用途，理解它的C#实现方法，理解委托与事件为我们带来的好处。C#是一种新的语言，希望大家能通过本文清楚地看到这些，从而可以对委托、事件等技术进行更深入的理解和探索。

一. 委托

委托的本质
  --在C#中，委托是一个特殊的类；
  --在某种程度上，相当于C++的函数指针；
  --在某种程度上，相当于接口(Interface)；

委托的定义
  --关键字：delegate
  --public delegate void MyDelegate(string message);
  注：在这里我们先了解一个概念，什么是函数签名？(在这里我不做过多解释,大家知道这个概念就行)。

使用委托
  我们先来看看一个小的委托示例：
  平时，如果说我们要设计一个做简单加减运算的方法，通常是怎么做的呢？看看下面代码：

1class Program
 2    {
 3        /**//// <summary>
 4        /// 加法运算
 5        /// </summary>
 6        /// <param name="x">x</param>
 7        /// <param name="y">y</param>
 8        /// <returns></returns>
 9        private static int Add(int x, int y)
10        {
11            int result = x + y;
12            Console.WriteLine("x + y = {0}",result);
13            return result;
14        }
15
16        /**//// <summary>
17        /// 减法运算
18        /// </summary>
19        /// <param name="x">x</param>
20        /// <param name="y">y</param>
21        /// <returns></returns>
22        private static int Sub(int x, int y)
23        {
24            int result = x - y;
25            Console.WriteLine("x - y = {0}", result);
26            return result;
27        }
28
29        static void Main(string[] args)
30        {
31            Add(8, 8);
32            Sub(8, 1);
33            Console.Read();
34        }
35    }

上面的代码只要是学过程序的人都能看懂，也写得出，不过我们怎么通过委托来处理+,-运算呢？请看下面定义：

1namespace DelegateSample1
 2{
 3    //定义一委托
 4    public delegate int OperationDelegate(int x,int y);
 5    public class Operator
 6    {
 7        private int _x, _y;
 8        public Operator(int x, int y)
 9        {
10            this._x = x;
11            this._y = y;
12        }
13
14        public void Operate(OperationDelegate del)
15        {
16            del(_x, _y);
17        }
18    }
19}

上面定义一个返回int类型需要两个int参数的委托。Operator里提供了一个操作方法带有一个委托参数。那通过委托怎么来处理这个简单的运算呢？好，现在我们来修改我们之前定义的主方法，如下：

1namespace DelegateSample1
 2{
 3    class Program
 4    {
 5        /**//// <summary>
 6        /// 加法运算
 7        /// </summary>
 8        /// <param name="x">x</param>
 9        /// <param name="y">y</param>
10        /// <returns></returns>
11        private static int Add(int x, int y)
12        {
13            int result = x + y;
14            Console.WriteLine("x + y = {0}",result);
15            return result;
16        }
17
18        /**//// <summary>
19        /// 减法运算
20        /// </summary>
21        /// <param name="x">x</param>
22        /// <param name="y">y</param>
23        /// <returns></returns>
24        private static int Sub(int x, int y)
25        {
26            int result = x - y;
27            Console.WriteLine("x - y = {0}", result);
28            return result;
29        }
30
31        static void Main(string[] args)
32        {
33            //声明一个委托对象
34            OperationDelegate del = null;
35            del += new OperationDelegate(Add);
36            del += new OperationDelegate(Sub);
37
38            Operator op = new Operator(5, 3);
39            op.Operate(del);
40            Console.ReadLine();
41        }
42    }
43}
44

从上面的例子看，委托OperationDelegate代表了一组方法，他们的方法签名是：
   --返回值：int； 参数：int ,int ；
   只要符合该签名的方法，都可以赋给此委托：从上面不难看出，我要要创建一委托，则如下定义：

1OperationDelegate del += new OperationDelegate(方法名);

从上面可以看到(+=)这个运算符，那是不是也有(-=)这个运算符呢？这就涉及到另外一个概念了--委托链。
   --委托链：实际上委托实例就是一个委托链，+=代表增加委托实例到委托链中，相反-=则代表去掉该委托实例。

1OperationDelegate del = null;
2del += new OperationDelegate(Add); //增加委托实例到委托链
3del -= new OperationDelegate(Add); //去掉委托实例到

委托的意义之一
  --委托可以使得程序的复用程度提高；
  --委托在一定程度上想当于接口；
  例如：前面例子中的方法Operate()，由于接受的是一个委托类型；那么，我们可以对委托类型赋予不同的方法，来改变Operate()的性质。

我们在来看看另外一个示例：
  --我们想输出一串数字，从0-100；
  --对于输出的要求有三种；
   -1、输出到控制台
   -2、输出到窗体中的ListBox中；
   -3、输出到文本文件中；
  解决方案：
  --使用委托和接口， 代码如下：

1namespace DelegateSample2
 2{
 3    //定义一委托
 4    public delegate void ShowNumberDel(object[] items);
 5    public class ProcessNumber
 6    {
 7        private object[] items;
 8        public ProcessNumber(int max)
 9        {
10            items = new object[max];
11            for (int i = 0; i < max; ++i)
12            {
13                items[i] = i;
14            }
15        }
16
17        public void ProcessItems(ShowNumberDel show)
18        {
19            show(items);
20        }
21    }
22}
23

在这里我们先把界面上的控件布局好并做好调用委托的准备工作，效果及代码如下：
                   
代码如下：

1private ProcessNumber pn = null;
 2ShowNumberDel del = null;
 3
 4private void Form1_Load(object sender, EventArgs e)
 5{
 6     pn = new ProcessNumber(100);
 7}
 8
 9//到控制台
10private void ShowInConsole(object[] items)
11{
12    foreach (object item in items)
13    {
14        Console.WriteLine(item);
15    }
16}
17
18//到ListBox
19private void ShowInListBox(object[] items)
20{
21    listBox1.Items.Clear();
22    foreach (object item in items)
23    {
24        listBox1.Items.Add(item);
25    }
26}
27
28//到文本文件
29private void ShowInFile(object[] items)
30{
31   using (StreamWriter sw = new StreamWriter("Test.txt", true))
32   {
33       foreach (object item in items)
34       {
35           sw.WriteLine(item);
36       }
37   }
38}

使用委托：

1private void button1_Click(object sender, EventArgs e)
 2{
 3    pn.ProcessItems(new ShowNumberDel(ShowInConsole));
 4}
 5
 6private void button2_Click(object sender, EventArgs e)
 7{
 8    pn.ProcessItems(new ShowNumberDel(ShowInListBox));
 9}
10
11private void button3_Click(object sender, EventArgs e)
12{
13    pn.ProcessItems(new ShowNumberDel(ShowInFile));
14}
15
16private void button4_Click(object sender, EventArgs e)
17{
18    del += new ShowNumberDel(this.ShowInListBox);
19    del += new ShowNumberDel(this.ShowInFile);
20
21    pn.ProcessItems(del);
22}

完整的测试代码如下：

使用委托的完整测试代码
 1using System;
 2using System.Collections.Generic;
 3using System.ComponentModel;
 4using System.Data;
 5using System.Drawing;
 6using System.Text;
 7using System.Windows.Forms;
 8using System.IO;
 9
10namespace DelegateSample2
11{
12    public partial class Form1 : Form
13    {
14        public Form1()
15        {
16            InitializeComponent();
17        }
18
19        private ProcessNumber pn = null;
20        ShowNumberDel del = null;
21
22        private void Form1_Load(object sender, EventArgs e)
23        {
24            pn = new ProcessNumber(100);
25        }
26
27        private void ShowInConsole(object[] items)
28        {
29            foreach (object item in items)
30            {
31                Console.WriteLine(item);
32            }            
33        }
34        private void ShowInListBox(object[] items)
35        {
36            listBox1.Items.Clear();
37            foreach (object item in items)
38            {
39                listBox1.Items.Add(item);
40            }
41        }
42        private void ShowInFile(object[] items)
43        {
44            using (StreamWriter sw = new StreamWriter("Test.txt", true))
45            {
46                foreach (object item in items)
47                {
48                    sw.WriteLine(item);
49                }
50            }
51        }
52
53        private void button1_Click(object sender, EventArgs e)
54        {
55            pn.ProcessItems(new ShowNumberDel(ShowInConsole));             
56        }
57
58        private void button2_Click(object sender, EventArgs e)
59        {
60            pn.ProcessItems(new ShowNumberDel(ShowInListBox));
61        }
62
63        private void button3_Click(object sender, EventArgs e)
64        {
65            pn.ProcessItems(new ShowNumberDel(ShowInFile));
66        }
67
68        private void button4_Click(object sender, EventArgs e)
69        {
70            del += new ShowNumberDel(this.ShowInListBox);
71            del += new ShowNumberDel(this.ShowInFile);
72            pn.ProcessItems(del);
73        }   
74    }
75}

委托的意义之二
   --在C#中使用线程需要用到委托
    - Thread thread = new Thread(new ThreadStart(target));

−     -这里的ThreadStart就是一个委托，他的定义是：
     -target既为符号ThreadStart委托的方法名；
  
   --函数回调
    - 当我们定义了一个委托；
       public delegate void MyDelegate(int source);

-对于异步调用来说，就有BeginInvoke()和EndInvoke()方法；  
    -del.BeginInvoke(source, new System.AsyncCallback(CallBack), "test");

-private void CallBack(IAsyncResult asyncResult)
      {
            int result = del.EndInvoke(asyncResult);
            //......
      }
  这里需要理解的就是什么叫函数回调？这个话题留给大家讨论，在此不作详细解说。关于委托本文只是入门级的文章，要想更详细深入的学习委托请查看具体的书籍或资料，本文就简单介绍到这里。

文中示例代码下载：Delegate.Event.Thread(1).rar

时间： 2024-11-07 12:11:27

C#编程之委托与事件四（一）【转】的相关文章

C#编程之委托与事件四(二)【转】

C#编程之委托与事件(二) 我在上一篇文章(C#编程之委托与事件(一) )中通过示例结合的方法介绍了委托,在本文中,我同样以代码示例的方式来介绍C#里的事件机制. 二.事件   1.了解概念      事件就是当对象或类状态发生改变时,对象或类发出的信息或通知.发出信息的对象或类称为"事件源",对事件进行处理的方法称为"接收者",通常事件源在发出状态改变信息时,它并不知道由哪个事件接收者来处理.这就需要一种管理机制来协调事件源和接收者,C++中通过函数指针来完成的.

《C#高级编程》委托、事件的示例代码

运行结果: Program.cs 1 using System; 2 3 namespace Wrox.ProCSharp.Delegates 4 { 5 class Program 6 { 7 static void Main() 8 { 9 var dealer = new CarDealer(); 10 11 var michael = new Consumer("Michael"); 12 dealer.NewCarInfo += michael.NewCarIsHere; 1

C#中委托和事件

目 录 1.1 理解委托 2 1.1.1 将方法作为方法的参数 2 1.1.2 将方法绑定到委托 4 1.2 事件的由来 6 1.2.1 更好的封装性 6 1.2.2 限制类型能力 9 1.3 委托的编译代码 10 1.4 .NET 框架中的委托和事件 11 1.4.1 范例说明 11 1.4.2 Observer 设计模式简介 12 1.4.3 实现范例的Observer 设计模式 13 1.4.4 .NET 框架中的委托与事件 14 1.5 委托进阶 16 1.5.1 为什么委托定义的返回值

C# 之委托和事件（转载）

概述:委托和事件在 .NET Framework 中的应用非常广泛,然而,较好地理解委托和事件对很多接触 C# 时间不长的人来说并不容易.它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没有过去的人每次见到委托和事件就觉得心里堵得慌,浑身不自在.本章中,我将由浅入深地讲述什么是委托.为什么要使用委托.事件的由来..NET Framework 中的委托和事件.委托中方法异常和超时的处理.委托与异步编程.委托和事件对Observer 设计模式的意义,对它们的编译代码也做了讨论. 1.1 理解

第12章 委托与事件

委托和事件在 .NET Framework 中的应用非常广泛,然而,较好地理解委托和事件对很多接触 C# 时间不长的人来说并不容易.它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没有过去的人每次见到委托和事件就觉得心里堵得慌,浑身不自在.本章中,我将由浅入深地讲述什么是委托.为什么要使用委托.事件的由来..NET Framework 中的委托和事件.委托中方法异常和超时的处理.委托与异步编程.委托和事件对Observer 设计模式的意义,对它们的编译代码也做了讨论. 12.1将方法作为

C#编程（四十二）----------委托和事件

委托和事件 委托是C#总比较重要的概念,学习C#爱这里最容易产生迷惑. 有些时候,犹豫我们在开发程序时对后续可能出现的要求及变化考虑不足而导致麻烦,这些新变化可能导致程序的重新编写,那能不能改变这种情况?后面的需要变化了,后续对应功能的编写对前面的程序不造成影响? 可以的,在C#中可以使用委托来解决这个问题. delegate 怎么理解委托呢,形象一点就是你的名字叫张三,别人一叫张三,你就答应.就像程序调用一样,一个叫(调用)一个回答(执行).但是不久你因为给老板舔的好,给你升职了,你成了经理了

四、集合与泛型、委托与事件-----《大话设计模式》

一.集合与泛型   数组 集合(ArrayList) 泛型 优点 连续存储.快速从头到尾遍历和修改元素 使用大小可按需动态增加 类型安全:省去拆箱和装箱操作 缺点 创建时必须制定数组变量的大小: 两个元素之间添加元素比较困难 类型不安全,接受所有类型的数据: 导致一直进行拆箱和装箱操作,带来很大的性能消耗   public partial class Form1 : Form { IList arrayAnimal_list = new ArrayList(); //声明并初始化集合 IList

.NET基础拾遗（4）委托、事件、反射与特性

Index : (1)类型语法.内存管理和垃圾回收基础 (2)面向对象的实现和异常的处理基础 (3)字符串.集合与流 (4)委托.事件.反射与特性 一.委托基础 1.1 简述委托的基本原理 委托这个概念对C++程序员来说并不陌生,因为它和C++中的函数指针非常类似,很多码农也喜欢称委托为安全的函数指针.无论这一说法是否正确,委托的的确确实现了和函数指针类似的功能,那就是提供了程序回调指定方法的机制. 在委托内部,包含了一个指向某个方法的指针(这一点上委托实现机制和C++的函数指针一致),为何称其

[转]大白话系列之C#委托与事件讲解(三)

本文转自:http://www.cnblogs.com/wudiwushen/archive/2010/04/21/1717378.html [我希望大家在看完文章的时候,多做做练习,自己也可以想个场景,动动手,这样才会有深刻的印象,不然遗忘的速度非常快] 今天我接着上面的3篇文章来讲一下,为什么我们在日常的编程活动中遇到这么多sender,EventArgs e 参数: protected void Page_Load(object sender, EventArgs e) { } prote