• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

委托C#生活实例

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

现实中的例子:
比如说一个公司(场景),你是老板,手下有两个员工,小张和小王。
你命令小王,如果小张玩游戏,则小王扣去小张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 = 10000; // 构造函数,初始化小张的钱。
}
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);
if(PlayGame != null)
{
PlayGame(this,e);
}
}
protected virtual void OnPlayGame(EventArgs e)
{
if(PlayGame != null)
{
PlayGame(this,e);
}
}
}
// 定义委托处理程序
public delegate void PlayGameHandler(object sender,System.EventArgs e);
}

=========================================================
刚开始在理解委托和事件时常常被msdn搞糊涂,为了快速应用.net的委托和事件模型编程,可以先看看如下的代码
using System;
namespace delegeteTest
{
class delegeteClass
{
public delegate void fHandler(int a); //关键-此行可以看成类的声明
public fHandler f0;
public void d(int a,int b )
{
int c=a+b;
f0(c);
}
}
class test
{
public void output(int mun)
{
System.Console .WriteLine ("{0}",mun);
}
[stathread]
static void Main(string[] args)
{
test t=new test ();
delegeteClass dc=new delegeteClass ();
dc.f0 =new delegeteTest.delegeteClass.fHandler (t.output);//实例的初始化
dc.d(2,3);
}
}
}
解释一下"关键": 实际上 public delegate void fHandler(int a);可以看成如下:
class fHandler
{.....}
类内部由编译器自动完成,是一个sealed类通过反汇编可以看到,是一个类的声明,它检查加入自己的函数的信息,如,返回值和参数类型
现在熟悉vc++的人可能感觉到public delegate void fHandler(int a);这句就象一个宏
现在好了既然是个类的定义,那么也可以直接拿到命名空间下了
using System;
namespace delegeteTest
{
public delegate void fHandler(int a);//fHandler现在上升到了类的层次
class delegeteClass
{
public fHandler f0;//声明了委托fHandler的实例f0;
public fHandler f1;//也可以再声明一个fHandler类的实例f1;
public void d(int a,int b )
{
int c=a+b;
f0(c);
}
}
class test
{
public void output(int mun)
{
System.Console .WriteLine ("{0}",mun);
}
[stathread]
static void Main(string[] args)
{
test t=new test ();
delegeteClass dc=new delegeteClass ();
dc.f0 =new delegeteTest.fHandler (t.output);//此行做相应的修改
dc.d(2,3);
}
}
}
有以上可知public delegate void fHandler(int a)这行代码只能放在能够声明类的地方,自然fHandler.后面的函数都是静态方法了,如fHandler.Equals (...);
那么fhandler到底声明了什么? 实际上是声明了函数的类型,既函数的有关信息(如返回值,参数类型)。说到委托还是要说一下委托类型的实例。在msdn中的很多地方,(委托)这个词指的是委托类型的实例,它拥有了一个列表,列表的每一项包含了函数信息和函数所在的对象的引用。
在声明fhandler类的实例f0的时候,f0还不能用,是空的,所以f0需要初始化 dc.f0 =new delegeteTest.fHandler (t.output); 初始化的参数包含了两个信息 t--对象的引用,output--函数信息,如果把初始化的这句注释掉,你运行一下看有什么信息----“未将对象引用设置到对象的实例”。另外output函数的参数和返回值需要和fHandler的类声明一致,这是由编译器在编译时检查的。
经过初始化之后 现在实例中有了一项数据(实际上大多数只有一项,这样效率比较高,也就是single cast的,此时实例是Delegate类型的(注意是大写的D))。
现在说一下委托的多播(multi cast),实际上委托的多播就是把列表里的每一项函数调用一次),但是多播的效率不是很高的所以委托的大部分实例都是单播(single cast),另外可能委托的实例会根据列表内函数的个数来运行不同的机制(这里我们就没必要研究它了)。看下面的代码:
namespace delegeteTest
{
public delegate void fHandler(int a);
class delegeteClass
{
public fHandler f0;
public fHandler f1;
public void d(int a,int b )
{
int c=a+b;
f1(c); //合并指针列表的多播委托
}
}
class test
{
public void output(int mun)
{
System.Console .WriteLine (" 函数1显示{0}",mun);
}
public void output1(int mun)
{
System.Console .WriteLine (" 函数2显示{0}",mun);
}
[stathread]
static void Main(string[] args)
{
test t=new test ();
delegeteClass dc=new delegeteClass ();
dc.f0 =new delegeteTest.fHandler (t.output);
dc.f1 =new fHandler (t.output1 );
system.console .WriteLine ("第一次触发");
dc.d (2,3);//第一次触发
dc.f1 =(fHandler)Delegate.Combine (dc.f0 ,dc.f1 );//合并生成新的]函数列表
dc.f1 =(fHandler)MulticastDelegate.Combine (dc.f1 ,dc.f0 );//同上
System.Console .WriteLine ("第二次触发");
dc.d(2,3);//第二次触发
}
}
}
实际上dc.f1 =(fHandler)MulticastDelegate.Combine (dc.f1 ,dc.f0 );和dc.f1 =(fHandler)Delegate.Combine (dc.f1 ,dc.f0 );效果是一样的;由上面的例子可知我们完全可以由delegate 来构造我们自己的事件。微软为了方便大家进行编程,为我们提供了event。
using System;
namespace delegeteTest
{
public delegate void fHandler(int a);
class delegeteClass
{
public fHandler f0;
public fHandler f1;
public event fHandler f3; //关键--实际上此行也可以看成一个宏
public void d(int a,int b )
{
int c=a+b;
f3(c); // 改由event进行
}
}
class test
{
public void output(int mun)
{
System.Console .WriteLine (" 第1显示{0}",mun);
}
public void output1(int mun)
{
System.Console .WriteLine (" 第2显示{0}",mun);
}
[stathread]
static void Main(string[] args)
{
test t=new test ();
delegeteClass dc=new delegeteClass ();
dc.f0 =new delegeteTest.fHandler (t.output);
dc.f1 =new fHandler (t.output1 );
dc.f3 +=new fHandler(t.output); //f3是event
System.Console .WriteLine ("第一次触发");
dc.d (2,3);//第一次触发
system.console .WriteLine ("第二次触发");
dc.f3 +=(fHandler)Delegate.Combine (dc.f0 ,dc.f1 );//添加列表到f3
dc.d(2,3);//第二次触发
}
}
}
通过ildasm反汇编可以看到public event fHandler f3宏声明了两个成员
.field private class delegeteTest.fHandler f3和对f3的一个包装:
.event delegeteTest.fHandler f3
{
.addon instance void delegeteTest.delegeteClass::add_f3(class delegeteTest.fHandler)
.removeon instance void delegeteTest.delegeteClass::remove_f3(class delegeteTest.fHandler)
},
所以上面部分代码可以替换成如下:
private fHandler _f3;//由于不能与属性名相同,所以用_f3,是私有
public event fHandler f3
{
add
{
this._f3 += value;
}
remove
{
this._f3 -= value;
}
}
event 关键字方便了大家的习惯,同时它(由event定义的事件)在类的外部使用时隐藏了它的成员函数(这一点非常重要,几乎就是使用event关键字的原因),并且只能用“+=”和“-=”来操作,除此之外和直接声明public fHandler f3没有区别。它可以和上面的f0,f1一样允许有各种参数和返回值。是在委托基础上的。实际上我们都能用delegate 来构造我们想要的事件,这就是delegate 在.net里的地位很高的原因。
下面探讨一般控件的事件模型
先谈一下控件里的"on事件名"这个函数 如:OnTextChange(EventArgs e),类似的有很多,实际上这是一种编程方面的习惯,他代表的是引发这个TextChanged事件(注意不是代表TextChanged(e)的函数),具体的说就是在Text变量已经被赋值后执行的一个函数OnTextChanged(),OnTextChanged里面包含了类似TextChanged(e)这样的引发事件的代码。如果你重写了OnTextChanged(),而没有在(重写的函数)里添加base.OnTextChanged(e);那么你在外部添加的TextChanged事件的处理程序,永远也不会触发到,也就是TextChanged事件失效了。
下面写了一个重写ontextchanged()的例子,是关于只能输入数字的textbox, 里面有输入整数部分的数量限制属性 MaxOfInt 和小数限制属性MaxOfLittle,还有decimal 类型的值 ValueDecimal属性,还有一个DecmalValueChanged事件,由于重写了OnTextChanged事件而没有在里面写base.TextChanged (e);所以你们如果再使用TextChanged事件就一点效果都没有了。
下面的控件不怕粘贴,不怕汉字
using System;
using System.ComponentModel;
using System.ComponentModel .Design ;
namespace contr
{
/// <summary>
///
/// </summary>
public class TextBoxNum : System.Windows.Forms.TextBox
{
public delegate void ValueChangedHandler(object o,decimal DecValue);
private ValueChangedHandler ValueChanged;//声明了一个实例
public int MaxInt=8;
public int MaxLittle=2;
public decimal DecimalValue=0;
public TextBoxNum()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
private void InitializeComponent()
{
}
protected override void OnTextChanged(EventArgs e)
{
if(this.Text .Length !=0&&(this.Text[0])=='.')
{
this.Text ="0.";
this.SelectionStart=(this.Text .Length );
return;
}
string s=this.Text.Trim ();
if(this.MaxLittle ==0)
{
if(s.IndexOf ('.')>0||this.Text .Length >this.MaxInt )
{
this.Text =this.ValueDecimal .ToString ();
this.SelectionStart=(this.Text .Length );
return;
}
}
if(s ==""){return;}
int j=s .IndexOf ('.');
if((j<0&&s.Length >this.MaxInt ))
{
this.text =this.ValueDecimal .ToString ();
this.SelectionStart=(this.Text .Length );
return;
}
if(j>-1&&(s.Length -j-1)>this.MaxLittle)
{
this.Text =this.ValueDecimal .ToString ();
this.SelectionStart=(this.Text .Length );
return;
}
int a=0;
char[] temp=s.ToCharArray () ;
for(int i=0;i<s.Length ;i++)
{
if(Char.IsDigit(temp))
{
continue;
}
else if(temp=='.')
{
a++;
if(a>1)
{
this.Text =this.ValueDecimal .ToString ();
this.SelectionStart=(this.Text .Length );
return;
}
continue;
}
this.Text =this.ValueDecimal .ToString ();
this.SelectionStart=(this.Text .Length );
return;
}
this.ValueDecimal =decimal.Parse (this.Text);
base.TextChanged (e);
}
public event ValueChangedHandler DecmalValueChanged
{
add
{
this.ValueChanged += value;
}
remove
{
this.ValueChanged -= value;
}
}
public decimal ValueDecimal
{
get
{
return this.DecimalValue ;
}
set
{
this.DecimalValue =value;
if(ValueChanged!=null)
{
ValueChanged(this,this.DecimalValue );
}
}
}
[Browsable(true),DefaultValue(8)]
public int MaxOfInt
{
get
{
return this.MaxInt ;
}
set
{
if(value<=29)
{
this.MaxInt =value;
this.MaxLength =this.MaxLittle +value +1;
}
else
{
this.MaxInt =29;
this.MaxLength =this.MaxLittle +29 +1;
}
}
}
[Browsable(true),DefaultValue(2)]
public int MaxOfLittle
{
get
{
return this.MaxLittle ;
}
set
{
if(value<=29)
{
this.MaxLittle =value;
this.MaxLength =value +this.MaxInt +1;
}
else
{
this.MaxLittle =29;
this.MaxLength =29 +this.MaxInt +1;
}
}
}
}
}


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap