委托与事件 机制

合集下载

.Net笔试题1

.Net笔试题1

.Net笔试题1:说说什么叫字符串不可变?string s="abc";s="123"字符串s不就变了吗?答:String 对象是不可改变的。

每次使用System.String 类中的方法之一时,都要在内存中创建一个新的字符串对象,这就需要为该新对象分配新的空间。

String是不可变的。

在这段代码中,s原先指向一个String对象,内容是 "abc",然后我们将s指向"123",那么s所指向的那个对象是否发生了改变呢?答案是没有。

这时,s不指向原来那个对象了,而指向了另一个String对象,内容为"123",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。

扩展:在需要对字符串执行重复修改的情况下,与创建新的String 对象相关的系统开销可能会非常昂贵。

如果要修改字符串而不创建新的对象,则可以使用System.Text.StringBuilder 类。

例如,当在一个循环中将许多字符串连接在一起时,使用StringBuilder类可以提升性能。

.net笔试题2:BS与CS的联系与区别?答:C/S是Client/Server的缩写。

客户端需要安装专用的客户端软件。

B/S是Brower/Server的缩写,客户机上只要安装一个浏览器。

在这种结构下,用户界面完全通过浏览器实现,一部分事务逻辑在前端实现,但是主要逻辑在服务器端实现。

浏览器通过Web Server 同数据库进行数据交互。

C/S 与B/S 区别:1).硬件环境不同:C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.B/S 一般建立在广域网之上的, 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行。

2).对安全要求不同C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息.B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。

js中的事件委托(事件代理)详解

js中的事件委托(事件代理)详解

js中的事件委托(事件代理)详解本⽂转载:js中的事件冒泡、事件委托是js 中⼀些需要注意的⼩知识点,这⾥结合转载⽂章总结⼀下:事件冒泡:JS中当出发某些具有冒泡性质的事件是,⾸先在触发元素寻找是否有相应的注册事件,如果没有再继续向上级⽗元素寻找是否有相应的注册事件作出相应,这就是事件冒泡。

事件委托:利⽤事件冒泡的特性,将本应该注册在⼦元素上的处理事件注册在⽗元素上,这样点击⼦元素时发现其本⾝没有相应事件就到⽗元素上寻找作出相应。

这样做的优势有:1.减少DOM操作,提⾼性能。

2.随时可以添加⼦元素,添加的⼦元素会⾃动有相应的处理事件。

转载⽂章内容:起因:1、这是前端⾯试的经典题型,要去找⼯作的⼩伙伴看看还是有帮助的;2、其实我⼀直都没弄明⽩,写这个⼀是为了备忘,⼆是给其他的知其然不知其所以然的⼩伙伴们以参考;概述:那什么叫事件委托呢?它还有⼀个名字叫事件代理,JavaScript⾼级程序设计上讲:事件委托就是利⽤事件冒泡,只指定⼀个事件处理程序,就可以管理某⼀类型的所有事件。

那这是什么意思呢?⽹上的各位⼤⽜们讲事件委托基本上都⽤了同⼀个例⼦,就是取快递来解释这个现象,我仔细揣摩了⼀下,这个例⼦还真是恰当,我就不去想别的例⼦来解释了,借花献佛,我摘过来,⼤家认真领会⼀下事件委托到底是⼀个什么原理:有三个同事预计会在周⼀收到快递。

为签收快递,有两种办法:⼀是三个⼈在公司门⼝等快递;⼆是委托给前台MM代为签收。

现实当中,我们⼤都采⽤委托的⽅案(公司也不会容忍那么多员⼯站在门⼝就为了等快递)。

前台MM收到快递后,她会判断收件⼈是谁,然后按照收件⼈的要求签收,甚⾄代为付款。

这种⽅案还有⼀个优势,那就是即使公司⾥来了新员⼯(不管多少),前台MM也会在收到寄给新员⼯的快递后核实并代为签收。

这⾥其实还有2层意思的:第⼀,现在委托前台的同事是可以代为签收的,即程序中的现有的dom节点是有事件的;第⼆,新员⼯也是可以被前台MM代为签收的,即程序中新添加的dom节点也是有事件的。

C#基础知识学习之?委托(delegate)与事件(event)之间的介绍

C#基础知识学习之?委托(delegate)与事件(event)之间的介绍

C#基础知识学习之✨委托(delegate)与事件(event)之间的介绍委托(delegate) 与事件(event)前言在之前的文章里介绍了C#中的委托(delegate)(Action、Func、Predicate)的基本含义及用法那本篇文章在这里还要介绍一个跟委托有很大关系的小伙伴——C#中的事件(event)事件跟委托是有很大联系的,所以也就导致很容易分不清他们两个,以及什么时候用这两个上面有博客提到委托,想单独了解委托的可以去看一下,本篇文章主要说一下什么是事件以及事件与委托的区别委托和事件的定义委托在这里再说一遍委托跟事件的简单定义(没有搜到特别准确的,都是大概定义,理解万岁)委托:delegate 是一种可用于封装命名或匿名方法的引用类型。

委托类似于 C++ 中的函数指针;但是,委托是类型安全和可靠的。

委托是一种动态调用方法的类型,属于引用型。

委托是对方法的抽象和封装。

委托对象实质上代表了方法的引用(即内存地址)委托允许将方法作为参数进行传递。

委托可用于定义回调方法。

委托可以把多个方法链接在一起。

这样,在事件触发时可同时启动多个事件处理程序。

委托签名不需要与方法精确匹配。

事件事件:事件是特殊类型的多路广播委托,仅可从声明它们的类或结构(发行者类)中调用。

如果其他类或结构订阅了该事件,则当发行者类引发该事件时,会调用其事件处理程序方法。

事件表示C#中已定义的一个对象,即处理通知过程的对象通常,每个事件的发生都会产生发送方和接收方。

在.net框架中,事件是将事件发送者(触发事件的对象)与事件接受者(处理事件的方法)相关联的一种代理类,即事件机制是通过代理类来实现的。

当一个事件被触发时,由该事件的代理来通知(调用)处理该事件的相应方法委托和事件的区别简单说了一下两者的定义,眼神好的小伙伴这时候就会发现,事件的说明里有提到一句话:“事件也可以算一种特殊的委托”,这句话不是特别准确,但是也不妨可以这样理解。

C_窗体中Invoke和BeginInvoke方法详解

C_窗体中Invoke和BeginInvoke方法详解

在Invoke或者BeginInvoke的使用中无一例外地使用了委托Delegate,至于委托的本质请参考我的另一随笔:对.net事件的看法。

一、为什么Control类提供了Invoke和BeginInvoke机制?关于这个问题的最主要的原因已经是dotnet程序员众所周知的,我在此费点笔墨再次记录到自己的日志,以便日后提醒一下自己。

1、windows程序消息机制Windows GUI程序是基于消息机制的,有个主线程维护着一个消息泵。

这个消息泵让windows 程序生生不息。

Windows GUI程序的消息循环Windows程序有个消息队列,窗体上的所有消息是这个队列里面消息的最主要来源。

这里的while 循环使用了GetMessage()这个方法,这是个阻塞方法,也就是队列为空时方法就会被阻塞,从而这个while循环停止运动,这避免了一个程序把cpu无缘无故地耗尽,让其它程序难以得到响应。

当然在某些需要cpu最大限度运动的程序里面就可以使用另外的方法,例如某些3d游戏或者及时战略游戏中,一般会使用PeekMessage()这个方法,它不会被windows阻塞,从而保证整个游戏的流畅和比较高的帧速。

这个主线程维护着整个窗体以及上面的子控件。

当它得到一个消息,就会调用DispatchMessage 方法派遣消息,这会引起对窗体上的窗口过程的调用。

窗口过程里面当然是程序员提供的窗体数据更新代码和其它代码。

2、dotnet里面的消息循环public static void Main(string[] args){Form f = new Form();Application.Run(f);}Dotnet窗体程序封装了上述的while循环,这个循环就是通过Application.Run方法启动的。

3、线程外操作GUI控件的问题如果从另外一个线程操作windows窗体上的控件,就会和主线程产生竞争,造成不可预料的结果,甚至死锁。

C#事件(event)解析

C#事件(event)解析

C#事件(event)解析C#事件(event)解析事件(event),这个词儿对于初学者来说,往往总是显得有些神秘,不易弄懂。

而这些东西却往往又是编程中常用且非常重要的东西。

大家都知道windows消息处理机制的重要,其实C#事件就是基于windows消息处理机制的,只是封装的更好,让开发者无须知道底层的消息处理机制,就可以开发出强大的基于事件的应用程序来。

先来看看事件编程有哪些好处。

在以往我们编写这类程序中,往往采用等待机制,为了等待某件事情的发生,需要不断地检测某些判断变量,而引入事件编程后,大大简化了这种过程:- 使用事件,可以很方便地确定程序执行顺序。

- 当事件驱动程序等待事件时,它不占用很多资源。

事件驱动程序与过程式程序最大的不同就在于,程序不再不停地检查输入设备,而是呆着不动,等待消息的到来,每个输入的消息会被排进队列,等待程序处理它。

如果没有消息在等待,则程序会把控制交回给操作系统,以运行其他程序。

- 事件简化了编程。

操作系统只是简单地将消息传送给对象,由对象的事件驱动程序确定事件的处理方法。

操作系统不必知道程序的内部工作机制,只是需要知道如何与对象进行对话,也就是如何传递消息。

有了这么多好处,看来我们的确有必要掌握它。

俗话说:“难了不会,会了不难”。

就让我们一步一步开始吧...要讲事件,必然要讲到委托(delegate)。

它们之间的关系可以通过一个浅显的比方来说明,这个比方可能不是十分恰当。

比如你要租一个房屋,这是一个事件,那么委托就是房屋租赁中介,当你把租房子的消息告知中介后,中介就会产生出一套符合你要求的房屋租赁方案来。

再由中介执行这套方案,你便租得了这个房屋,即事件被处理了。

当然你也可以不通过中介,直接找房东,但如果没有互联网等工具,你如何得到谁出租房屋的信息?话题扯远了。

委托(delegate)委托可以理解成为函数指针,不同的是委托是面向对象,而且是类型安全的。

关于委托的理解,可以参考我的另一篇文章《C#委托之个人理解》。

Unity+C#游戏开发接口,委托与事件

Unity+C#游戏开发接口,委托与事件

游戏开发第五章接口,委托与目录 CONTENTS五.一接口零一五.二委托零二五.三零三内容简述"接口"理解为就是定义一套标准,然后由实现类来具体实现其地方法,接口就是一组类地抽象。

"委托"理解为"方法地抽象",也就是说定义一个方法地模板,至于这个方法具体是怎么样地,就由方法自己去实现。

是用户操作,例如:按键,点击,鼠标移动等。

或者某些,例如:系统生成地通知。

应用程序需求响应发生时。

五.一接口接口(interface)是C#地一种数据类型,属于引用类型。

一个接口定义一个协定。

接口可以包含方法,属,与索引器,接口本身不提供它所定义地成员地实现,接口只指定实现该接口地类或结构需要提供地成员。

实现某接口地类需要遵守该接口定义地协定,即需要提供接口成员地实现。

五.一.一 . 接口地定义一.定义接口是指定一组函数成员而不实现成员地引用类型,其它类型与接口可以继承接口。

二.特点通过接口可以实现多重继承,接口里面地方法都需求由外面接口实现去实现方法体,那么其修饰符必然是public。

接口成员不能有new,static,abstract,override,virtual修饰符。

接口只包含成员地签名,接口没有构造函数,所有不能直接使用new对接口行实例化。

C#是单继承,接口是解决C#里面类可以同时继承多个基类地问题。

五.一.二接口地使用接口地声明在C#,声明接口使用interface关键字,一般形式如下:[访问修饰符] interface 接口名[ : 基接口列表]{//接口成员}说明:接口成员可以是属,方法,索引器与,不能包含字段,构造函数等。

所有接口成员隐式地具有了public访问修饰符,因此,接口成员不能添加任何访问修饰符。

接口主要用来定义一个规则,让企业内部或行业内部地软件开发员按标准去实现应用程序地功能。

因此,继承接口地类或结构需要实现接口地所有属,方法,索引器与,继承接口地方法与继承类相似 接口地继承接口也可以继承其它接口,而接口可以多继承,即接口可以从多个接口继承,基接口名之间用逗号分隔。

委托和事件的区别

委托和事件的区别

委托和事件的区别(讲的很详细)--转委托和事件在 .Net Framework中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。

它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没有过去的人每次见到委托和事件就觉得心里别(biè)得慌,混身不自在。

本文中,我将通过两个范例由浅入深地讲述什么是委托、为什么要使用委托、事件的由来、.Net Framework中的委托和事件、委托和事件对Observer设计模式的意义,对它们的中间代码也做了讨论。

将方法作为方法的参数我们先不管这个标题如何的绕口,也不管委托究竟是个什么东西,来看下面这两个最简单的方法,它们不过是在屏幕上输出一句问候的话语:public void GreetPeople(string name) {// 做某些额外的事情,比如初始化之类,此处略EnglishGreeting(name);}public void EnglishGreeting(string name) {Console.WriteLine("Morning, " + name);}暂且不管这两个方法有没有什么实际意义。

GreetPeople用于向某人问好,当我们传递代表某人姓名的name参数,比如说“Jimmy”,进去的时候,在这个方法中,将调用EnglishGreeting方法,再次传递name参数,EnglishGreeting则用于向屏幕输出“Morning, Jimmy”。

现在假设这个程序需要进行全球化,哎呀,不好了,我是中国人,我不明白“Morning”是什么意思,怎么办呢?好吧,我们再加个中文版的问候方法:public void ChineseGreeting(string name){Console.WriteLine("早上好, " + name);}这时候,GreetPeople也需要改一改了,不然如何判断到底用哪个版本的Greeting问候方法合适呢?在进行这个之前,我们最好再定义一个枚举作为判断的依据:public enum Language{English, Chinese}public void GreetPeople(string name, Language lang){//做某些额外的事情,比如初始化之类,此处略swith(lang){case Language.English:EnglishGreeting(name);break;case Language.Chinese:ChineseGreeting(name);break;}}OK,尽管这样解决了问题,但我不说大家也很容易想到,这个解决方案的可扩展性很差,如果日后我们需要再添加韩文版、日文版,就不得不反复修改枚举和GreetPeople()方法,以适应新的需求。

委托和事件的直接理解

委托和事件的直接理解

初学者在理解委托和事件时常常被msdn搞糊涂,为了让初学.net的人快速应用.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.ou tput);//实例的初始化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到底声明了什么? 实际上是声明了函数的类型,既函数的有关信息(如返回值,参数类型)。

javascript事件与委托

javascript事件与委托

浏览模式: 标准 | 列表全部文章div 滚动条点击事件处理Submitted by chen0908 on 2012, May 23, 10:21 AM在用div模拟各种效果时候,div拥有滚动条,点击滚动条并不会触发 div的click事件。

(火狐内核可以) 替代解决方案可以把click 换成 Focus事件。

div本身Focus事件是不能被激活的,需要在div上有 tabindex属性。

Tags: 滚动条, click, divCSS&JS学习 | 评论:0 | Trackbacks:0 | 阅读:537for in 在webkit内核下面的特殊Submitted by chen0908 on 2012, May 23, 10:17 AMfor in循环如果遍历的对象的属性名是可以自动转换为数值型的字符串,在webkit下面会自动排序。

var json={"2":2,"4":"4","6":6,"1":1};var html="";for(var a in json){html+=json[a]}alert(html);ie浏览器输入的是 2461,webkit内核输入的是1234 解决方案是把属性名换成不能自动转换成数值的字符串比如说 _2 _4 _6 _1Tags: for in, chrome, webkitCSS&JS学习 | 评论:0 | Trackbacks:0 | 阅读:417javascript 事件委托Submitted by chen0908 on 2011, October 18, 11:59 AM7. 事其中提到了一个非常重要的概念就是事件委托。

事件委托的概念是基于事件触发的冒泡机制的。

XML/HTML代码1.<!DOCTYPE HTML>2.<html>3.<head>4.<meta http-equiv="Content-Type" content="text/html; charset=gb2312">5.<title>冒泡机制demo</title>6.<script src="jquery-1.6.4.min.js"></script>7.<script>8.$(function(){9. $('*').click(function(){10. alert(this.innerHTML);11. })12. })13.</script>14.</head>15.16.<body>17.<div>show <span>me</span></div>18.</body>19.</html>在以前firefox还有一个事件捕捉机制,事件捕捉机制就是先从最顶层的元素一层一层向子元素触发。

C#委托和事件从猫和老鼠的故事看事件

C#委托和事件从猫和老鼠的故事看事件

C#委托和事件从猫和老鼠的故事看事件1. 委托的含义:(MSDN)A delegate declaration defines a reference type that can be used to encapsulate a method with a specific signature.A delegate instance encapsulates a static or an instance method.Delegates are roughly similar to function pointers in C++;however,delegates are type-safe and secure.委托是一种引用方法的类型。

一旦为委托分配了方法,委托将与该方法具有完全相同的行为。

委托方法的使用可以像其他任何方法一样,具有参数和返回值。

我们可以这样理解委托:委托是函数的封装,它代表一“类”函数,它们都符合一定的签名:拥有相同的参数列表、返回值类型。

同时,委托也可以看成是对函数的抽象,是函数的类,此时的实例代表一个具体的函数。

2.事件的理解:C#使用委托模型来实现事件。

事件生成者类中不用定义事件的处理方法;事件订阅者是那些希望在事件发生时得到通知的对象,它们定义将和事件委托关联的事件处理方法。

当生成事件时,事件生成者通过调用事件委托“触发”事件,然后委托调用和它关联的事件处理方法。

3.猫和老鼠的例子首先,我们设定一个简单场景来说明,夜深人静,屋里有老鼠蹑手蹑脚的行动,且随时提防着猫,如果听到猫叫,老鼠闻声立即逃回洞里。

这个场景可以抽象为事件的几个要素:猫和老鼠是两个对象,猫是事件生成者对象,猫叫是一个方法,引发Cry事件;老鼠是事件订阅者对象,它提供事件处理程序Run()方法;通过委托和事件实现了老鼠对猫动静的监听,结果是老鼠听到猫叫就逃跑。

下面是完整的例子://定义一个委托,用来关联的Cry事件处理方法public delegate void CryEventHandler();//Cat类是事件的生成者,通过OnCry()方法引发Cry事件//但Cat类并不知道谁会监听Cry事件,以及如何理Cry事件,它只是告诉环境Cry事件发生了//通俗的解释是:猫叫了,但猫并不知道它的叫声对环境有什么影响public class Cat {//定义事件,表示猫叫public static event CryEventHandler Cry;public Cat() {Console.WriteLine("Cat:I'm coming.");}public virtual void OnCry() { Console.WriteLine("Cat:MiaoMiao");if (Cry != null) {Cry();}}}//Mouse类是事件的订阅者,定义了Cry事件发生时的处理方法Run()//通俗的解释是:老鼠在夜间行动时,时刻都在堤防着猫,如果听到猫叫声马上离开public class Mouse {public Mouse() {Cat.Cry += new CryEventHandler(Run);Console.WriteLine("Mouse:I go to find something,and I must always listen cat's crying.");}public void Run() {Console.WriteLine("Mouse:A cat is coming,I must go back!"); }}public class Demo1 {public static void Main(string[] args) {Mouse mouse = new Mouse();Cat cat = new Cat();cat.OnCry();Console.ReadLine();}}运行后控制台输出为:Cat:Mouse:I go to find something,and I must always listen cat's crying.I'm coming.Cat:MiaoMiao...Mouse:A cat is coming,I must go back!我们把猫和老鼠的场景设置复杂一点,假定有两种猫:一种是笨猫,它更本就追不上老鼠,所以老鼠即使听到它的叫声也不会逃走,对它描述为aBenCat;另一种猫就是能抓老鼠的猫了,让老鼠闻风丧胆,对它描述为smartCat。

C#中委托和事件的区别实例解析

C#中委托和事件的区别实例解析

C#中委托和事件的区别实例解析本⽂实例分析了C#中委托和事件的区别,分享给⼤家供⼤家参考之⽤。

具体如下:⼤致来说,委托是⼀个类,该类内部维护着⼀个字段,指向⼀个⽅法。

事件可以被看作⼀个委托类型的变量,通过事件注册、取消多个委托或⽅法。

本篇分别通过委托和事件执⾏多个⽅法,从中体会两者的区别。

⼀、通过委托执⾏⽅法class Program{static void Main(string[] args){Example example = new Example();example.Go();Console.ReadKey();}}public class Example{public delegate void DoSth(string str);internal void Go(){//声明⼀个委托变量,并把已知⽅法作为其构造函数的参数DoSth d = new DoSth(Print);string str = "Hello,World";//通过委托的静态⽅法Invoke触发委托d.Invoke(str);}void Print(string str){Console.WriteLine(str);}}上述代码实现:①在CLR运⾏时,委托DoSth实际上就⼀个类,该类有⼀个参数类型为⽅法的构造函数,并且提供了⼀个Invoke实例⽅法,⽤来触发委托的执⾏。

②委托DoSth定义了⽅法的参数和返回类型③通过委托DoSth的构造函数,可以把符合定义的⽅法赋值给委托④调⽤委托的实例⽅法Invoke执⾏了⽅法但实际上让委托执⾏⽅法还有另外⼀种⽅式,那就是:委托变量(参数列表)public class Example{public delegate void DoSth(object sender, EventArgs e);internal void Go(){//声明⼀个委托变量,并把已知⽅法作为其构造函数的参数DoSth d = new DoSth(Print);object sender = 10;EventArgs e = new EventArgs();d(sender, e);}void Print(object sender, EventArgs e){Console.WriteLine(sender);}}上述代码实现:①委托DoSth的参数列表和⽅法Print的参数列表还是保持⼀致②委托DoSth中的参数object sender通常⽤来表⽰动作的发起者,EventArgs e⽤来表⽰动作所带的参数。

第5章 OOP基础(4)——属性和委托事件

第5章 OOP基础(4)——属性和委托事件
5
5.6 委托和事件
委托,顾名思义,就是中间代理人的意思. 通俗地说,委托是一个可以引用方法的对象,当创建一个委 托,也就创建一个引用方法的对象,进而就可以调用那个方 法,即委托可以调用它所指向的方法. 事件是建立在委托基础上的另一个重要特性.从本质上说, 事件就是当某个事情发生时,会自动去执行一些语句.事件 是特殊化的委托,委托是事件的基础.
理解多播
委托可以调用多个方法,称为多播,使用+和-运算实现方法的 增加和减少.如,在上例基础上添加如下代码: Call d= new Call(objMath.Divide); objCall += d; objCall(5,3); 则运行时,先调用objMath.Multiply(5,3); 则运行时,先调用 ; 再调用objMath.Divide(5,3); 再调用 ;
4
示例说明
学生类定义了一个私有字段nAge,也定义了公有属 学生类定义了一个 , 性Age,并包含 和set两个访问器,使其既可读也 两个访问器, ,并包含get和 两个访问器 可写. 可写. 在属性的 访问器中,用return来返回一个事物的 在属性的get访问器中 访问器中, 在属性的 来返回一个事物的 属性值. 属性值. 在属性的 访问器中可以使用一个特殊的隐含参数 在属性的set访问器中可以使用一个特殊的 在属性的 value.该参数包含用户指定的值,通常用在 访问 .该参数包含用户指定的值,通常用在set访问 器中,将用户指定的值赋值到一个类变量中. 器中,将用户指定的值赋值到一个类变量中. 如果没有 访问器,则表示属性是只读的;如果没 如果没有set访问器 如果没有 访问器,则表示属性是只读的; 访问器则表示属性是只写的. 有get访问器则表示属性是只写的. 访问器则表示属性是只写的

详解C#委托,事件与回调函数

详解C#委托,事件与回调函数

详解C#委托,事件与回调函数.Net编程中最经常用的元素,事件必然是其中之一。

无论在还是WINFrom开发中,窗体加载(Load),绘制(Paint),初始化(Init)等等。

“protected void Page_Load(object sender, EventArgs e)”这段代码相信没有人不熟悉的。

细心一点一定会发现,非常多的事件方法都是带了“object sender, EventArgs e”这两个参数。

这是不是和委托非常相似呢?一、委托(有些书中也称为委派)委托是什么呢?这个名字的意思已经赋予了我们想象的空间,你是编程的,你现在正在写一个网页,而JS是你不熟悉的,于是你委托你的一位同事来帮助你完成JS部分。

这就是委托,把你所不能做的事情交给其他人去做。

而怎么知道是哪个人去做呢?当然是要知道名字!而为了区别名字一样的不同人,因此,需要描述一个特征。

在C#中,委托的作用是这样描述的:委托就像一个函数的指针,在程序运行时可以使用它们来调用不同的函数。

这个其实和你委托同事完成 JS代码一样。

如果有两位同事可以做这件事情,他们只要做的结果能够满足你的需求(就像一个接口),尽管他们做的过程不一样,并且作出的效果也不一样,但是,能够达到你的要求就可以了。

1.简单的委托那委托需要承载哪些信息呢?首先,它存储了方法名,还有参数列表(方法签名),以及返回的类型。

比如:delegate string/*返回类型*/ ProcessDelegate(int i);这就是一个委托的定义。

蓝色部分是声明委托的关键字,红色部分是返回的类型,而黑色部分是委托的类型名,和一个类名差不多,而()里的就是参数部分。

它的意思是,你要使用这个委托来做事情的话,那么,做事情的方法必须满足以下条件:1、返回类型和委托的返回类型一致,这里是string类型;2、能且只能有一个参数,并且是int类型。

OK,满足以上两个条件,一切就可以工作了:)例如:1 using System;2 using System.Collections.Generic;3 using System.Text;45 namespace TestApp6 {7 /// <summary>8 /// 委托9 /// </summary>10 /// <param name="s1"></param>11 /// <param name="s2"></param>12 /// <returns></returns>13 public delegate string ProcessDelegate(string s1, string s2);1415 class Program16 {17 static void Main(string[] args)19 /* 调用方法 */20 ProcessDelegate pd = new ProcessDelegate(new Test().Process);21 Console.WriteLine(pd("Text1", "Text2"));22 }23 }2425 public class Test26 {27 /// <summary>28 /// 方法29 /// </summary>30 /// <param name="s1"></param>31 /// <param name="s2"></param>32 /// <returns></returns>33 public string Process(string s1,string s2)34 {35 return s1 + s2;36 }37 }38 }输出的结果是:Text1Tex22、泛型委托泛型的委托,就是然参数的类型不确定,例如代码改写为:using System;using System.Collections.Generic;using System.Text;namespace TestApp{/// <summary>/// 委托/// </summary>/// <param name="s1"></param>/// <param name="s2"></param>/// <returns></returns>public delegate string ProcessDelegate<T,S>(T s1, S s2);class Program{static void Main(string[] args){/* 调用方法 */ProcessDelegate<string,int> pd = new ProcessDelegate<string,int>(new Test().Process); Console.WriteLine(pd("Text1", 100));}public class Test{/// <summary>/// 方法/// </summary>/// <param name="s1"></param>/// <param name="s2"></param>/// <returns></returns>public string Process(string s1,int s2){return s1 + s2;}}}输出的结果就是:Text1100泛型的详细内容不属于本文的介绍范围,这里不加多说了。

c委托与事件简单实例

c委托与事件简单实例

c委托与事件简单实例委托与事件是C#中常用的一种编程模式,它们可以让程序员更加灵活地控制程序的流程流转,使得程序的代码结构更加清晰,可读性更高。

在本文中,我们将以一个简单的例子来介绍委托与事件的使用方法,并探讨它们的一些重要特性。

假设我们正在开发一个游戏,这个游戏中有一个角色需要在不同场景下播放不同的动画。

我们可以使用一个委托来实现这个功能。

首先,我们需要声明一个委托类型,用来描述我们需要播放的动画:``` csharpdelegate void PlayAnimation(string animation);```这个委托类型表示一个接受一个字符串参数的方法,这个方法的返回值为 void,也就是没有返回值。

接着,我们可以定义一个包含这个委托类型为参数的方法:``` csharpvoid ChangeScene(PlayAnimation playAnimation){// 模拟切换场景的过程Console.WriteLine("正在切换场景……");// 播放动画playAnimation("idle");// 模拟切换场景完成的过程Console.WriteLine("场景切换完成!");}```这个方法接受一个 PlayAnimation 类型的参数 playAnimation,它的作用是在切换场景的过程中,播放一个名为 "idle" 的动画。

接下来,我们可以编写另外两个方法来实现这个委托:``` csharpvoid PlayIdle(string animation){Console.WriteLine("播放 " + animation + " 动画!");}void PlayWalk(string animation){Console.WriteLine("播放 " + animation + " 动画!");}```这两个方法是 PlayAnimation 类型的委托所需要的方法,它们接受一个字符串参数,用于指定播放的动画名称。

C#面向对象编程-委托和事件习题

C#面向对象编程-委托和事件习题
Console.write(i.ToString());
}
}
a)代码中存在错误,delegate void D(int i);不能定义在命名空间或者类之外
b)代码中存在错误,代码行V(new D(R));使用委托错误
c)程序正常运行,输出为0
d)程序正常运行,输出为210
C#面向对象编程-委托和事件
1.一个委托在某一时刻()指向多个方法。
a)可以
b)不可以
2.将事件通知其他对象的对象称为()
a)发布方
b)订户
c)通知方
3.以下的C#代码:
using System;
using System.Theading;
class App{
Public static voidMain()
b)代码正确编译和运行,并输出两次“将信寄往北大青鸟阿博泰克”;
c)代码将出现编译错误,
d)代码将编译正确,但运行时出现异常。
9>在C#中,假如有一个名为”MessageDelegate”的委托,下列能够正确定义
一个事件的是()
a)public delegate MessageDelegate messageEvent
Public class Carrier{
Public event SendMailDelegate sendEvent;
Static voidMain(){
Carrier t = new Carrier(); //1
t.sendEvent+= new SendMailDelegate(t_sendEvent);//2
b)public MessageDelegate messageEvent
c)private event MessageDelegate(messageEvent)

C#委托及事件

C#委托及事件

C#委托及事件在C#中,委托(delegate)是一种引用类型,在其他语言中,与委托最接近的是函数指针,但委托不仅存储对方法入口点的引用,还存储对用于调用方法的对象实例的引用。

简单的讲委托(delegate)是一种类型安全的函数指针,首先,看下面的示例程序,在C++中使用函数指针。

首先,存在两个方法:分别用于求两个数的最大值和最小值。

int Max(int x,int y){return x>y?x:y;}int Min(int x,int y){return x<Y?X:Y;< font>}上面两个函数的特点是:函数的返回值类型及参数列表都一样。

那么,我们可以使用函数指针来指代这两个函数,并且可以将具体的指代过程交给用户,这样,可以减少用户判断的次数。

下面我们可以建立一个函数指针,将指向任意一个方法,代码如下所示://定义一个函数指针,并声明该指针可以指向的函数的返回值为int类型,参数列表中包//括两个int类型的参数int (*p)(int,int);//让指针p指向Max函数p=max;//利用指针调用Maxc=(*p)(5,6);我们的问题在于,上面的代码中,为什么不直接使用Max函数,而是利用一个指针指向Max之后,再利用指针调用Max函数呢?实际上,使用指针的方便之处就在于,当前时刻可以让指针p指向Max,在后面的代码中,我们还可以利用指针p再指向Min函数,但是不论p指向的是谁,调用p时的形式都一样,这样可以很大程度上减少判断语句的使用,使代码的可读性增强!在C#中,我们可以使用委托(delegate)来实现函数指针的功能,也就是说,我们可以像使用函数指针一样,在运行时利用delegate动态指向具备相同签名的方法(所谓的方法签名,是指一个方法的返回值类型及其参数列表的类型)。

6.1 使用委托(delegate)6.1.1委托的建立建立委托(delegate),过程有点类似于建立一个函数指针。

java的委托事件模型

java的委托事件模型

java的委托事件模型
Java的委托事件模型是一种设计模式,用于将事件的发送者与接收者进行解耦,并允许多个接收者对同一个事件进行处理。

它基于观察者模式(Observer Pattern),通过定义事件源和事件监听器接口,实现事件的注册与触发,从而实现事件的发布与订阅。

在Java中,使用委托事件模型可以通过以下步骤实现:
1. 定义事件源:创建一个类,并在该类中定义触发事件的方法。

通常这个类会实现一个特定的事件源接口。

2. 定义事件监听器接口:创建一个接口,用于定义事件发生时需要执行的操作。

通常这个接口会包含一个或多个事件处理方法。

3. 注册事件监听器:在事件源类中定义一个集合(如List、Set等),用于存储事件监听器对象。

并提供注册和注销事件监听器的方法。

4. 触发事件:在事件源类的触发事件的方法中,遍历事件监听器集合,并依次调用监听器对象的事件处理方法。

5. 实现事件监听器:创建一个类,并实现事件监听器接口。

在该类中实现事件处理方法,用于对事件进行相应的处理逻辑。

通过以上步骤,可以实现事件的发布与订阅,当事件触发时,事件监听器会收到通知,并执行相应的操作。

这样可以使得事件的发送者与接收者解耦,提高程序的灵活性和可维护性。

vue事件冒泡方法

vue事件冒泡方法

vue事件冒泡方法Vue事件冒泡方法事件冒泡是指在DOM结构中,当一个元素触发了某个事件时,这个事件会向上冒泡,依次触发该元素的父元素的相同事件。

在Vue 中,事件冒泡是一种常见的交互方式,可以通过一些方法来控制事件的冒泡行为。

Vue中的事件冒泡机制是基于浏览器的事件冒泡机制的,Vue提供了一些特定的修饰符和方法来控制事件的冒泡行为。

1. 事件修饰符在Vue中,可以使用事件修饰符来控制事件的冒泡行为。

常见的事件修饰符有.stop和.prevent。

.stop修饰符可以阻止事件的冒泡行为,即在触发事件后,不会继续向上冒泡,而是停止在当前元素上。

.prevent修饰符可以阻止事件的默认行为,即在触发事件后,不会执行默认的操作。

例如,在一个按钮上绑定了一个点击事件@click,可以使用.stop 修饰符来阻止事件的冒泡行为:```<*****************="handleClick">点击</button>```2. 事件对象在Vue的事件处理函数中,可以通过$event参数访问到原生的事件对象,通过事件对象可以获取一些与事件相关的信息,如事件的目标元素、事件的类型等。

在事件对象中,有一个属性叫做`event.stopPropagation()`,可以用来停止事件的冒泡行为。

例如,在一个父元素上绑定了一个点击事件@click,可以在事件处理函数中使用`$event.stopPropagation()`方法来停止事件的冒泡行为:```<div @click="handleClick($event)"><*****************="handleButtonClick">点击</button> </div>methods: {handleClick(event) {event.stopPropagation();console.log('点击了父元素');},handleButtonClick() {console.log('点击了按钮');}}```3. 事件捕获除了事件冒泡,Vue还支持事件捕获。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Button1.Click+=new EventHandler(Button1_Click);-----------------@1
大家都熟悉的一段代码,Button1.Click是事件(也可以说是一条委托链),EventHandler 是委托,Button1_Click是订阅事件的人,也可以说是委托的人。

通过这样的机制,一个事件可以有多个订阅者,从而可以实现点击button可以响应多个方法。

委托,顾名思义,委托给别人。

事件,“发布者/订阅者” 模式,发布者发布一个事件,订阅者订阅这个事件,当事件触发时,就会通知订阅者。

通知这个过程是通过委托来实现的。

大家想象一下这个情景,经理有一个项目,计划A君负责美工方面,B君负责程序方面,将项目一分为二;于是一天,在用餐的时候告诉他们这个计划。

发布者:经理---------@2
订阅者订阅这个事件原因:A,B君是经理的部下 -------------@3
事件:经理分配了A,B一个项目-------------@4
触发事件的原因:经理有个计划----------------@5
通知方式(委托):”在用餐的时候告诉“方式----------------@6
public delegate void OneThing(object sender, CustomEventArgs e);定义一个委托,返回值为空,委托名OneThing,相当于@1中的EventHandler,有两个参数分别为触发事件的对象和事件信息。

Custom EventArgs必须继承于EventArgs
public class CustomEventArgs : EventArgs
{
public CustomEventArgs() //构造函数
{ }
}
声明事件public event OneThing DoThing;
那么要要定义一个触发事件的原因:假设当输入文本为“你们两个把这件事做完”(@5)就触发事件。

定义一个Text属性
public string Text
{
get
{
return _text;
}
set
{
_text = value;
if (_text == "你们两个把这件事做完")
this.DoThing(this, new CustomEventArgs());
else
Console.WriteLine("你没有触发事件");
}
}
一旦触发事件就要通过委托机制来告诉订阅者
DelegateExample de = new DelegateExample(); //DelegateExample 一个类,详见源代码de.DoThing +=new DelegateExample.OneThing(de.DoHalfThing);
de.DoThing += new DelegateExample.OneThing(de.DoOtherHalfThing);
当DoThing被触发时,就会委托给DohalfThing 和DoOtherHalfThing两个函数。

为这两个被委托的方法书写函数体
public void DoHalfThing(object sender, DelegateExample.CustomE ventArgs e)
{
Console.WriteLine("好的,我只做一半,另一半给别人做吧");
}
public void DoOtherHalfThing(object sender, DelegateExample.C ustomEventArgs e)
{
Console.WriteLine("好的,另一半就交给我好了");
}
注意其中的参数要和声明委托时相同
总的一个过程是,
输入“你们两个把这件事做完”,
触发事件DoThing
由于DoThing注册了事件处理事件(委托给)两个函数。

所以执行了两个函数。

所有代码
class DelegateExample
{
string _text;
public delegate void OneThing(object sender, CustomEventArg s e);
public event OneThing DoThing;
public string Text
{
get
{
return _text;
}
set
{
_text = value;
if (_text == "你们两个把这件事做完")
this.DoThing(this, new CustomEventArgs());
else
Console.WriteLine("你没有触发事件");
}
}
public class CustomEventArgs : EventArgs
{
public CustomEventArgs()
{ }
}
public void DoHalfThing(object sender, CustomEventArgs e)
{
Console.WriteLine("好的,我只做一半,另一半给别人做吧");
}
public void DoOtherHalfThing(object sender,CustomEventArgs e) {
Console.WriteLine("好的,另一半就交给我好了");
}
}
static void Main(string[] args)
{
#region委托与事件
DelegateExample de = new DelegateExample();
de.DoThing += new DelegateExample.OneThing(de.DoHalfThin g);
de.DoThing += new DelegateExample.OneThing(de.DoOtherHalf Thing);
string input = Console.ReadLine();
de.Text = input;
Console.ReadLine();
#endregion
}。

相关文档
最新文档