定义一个委托在什么位置定义，c 委托与事件定义在类里面还是类的外边

本文目录一览

1，c 委托与事件定义在类里面还是类的外边
2，C中委托应该定义在什么位置
3，C怎么定义一个委托把方法当参数传进去在线程里调用委托执行
4，请问C中的委托是什么如何使用
5，C用委托调用函数的步骤

1，c 委托与事件定义在类里面还是类的外边

事件是属于类的成员，所以是要放在类的内部的。委托，属于一个定义。其实是和类、接口类似的。通常是放在外部的。因为大多数委托都是要被重用的。

委托是事件的超集,事件是委托的一种特殊情况.就像类和接口一样. 不必纠结在什么时候用事件什么时候用委托.能用事件就用事件,不能用或不好用就自已建个委托.

c 委托与事件定义在类里面还是类的外边

2，C中委托应该定义在什么位置

是你的需求情况而定，一般定义在与类定义平级部分，且用public修饰，便于外部的调用。若定义于类的内部，则必须通过调用该类的成员才能取得其委托的引用，在频繁的调用该委托的情况下，就不是很适合。

1、不要把委托想象的太高深，委托就是一种特殊的类型，就像 string 之类的类型一样，只不过它特殊在是用来封装“方法”的。委托的定义需要跟它要封装的方法签名（返回类型、参数列表）相同。2、没太理解题主问的“重复产生自身的委托”，可能是因为题主不了解 invoke 的用法，所以提出了一个奇怪的问题，解释一下这段代码：public delegate void dg_func(int len,int data); /* * 定义一个委托类型，跟你定义一个别的类型一样，就像是 * public class student * * }*/public class a void func(int len, int data) if(控件.invokerequired) /* 当创建这个控件的线程以外的线程，想跨线程访问这个控件的时候，invokerequired 会为 true，否则为 false */ dg_func dg = new dg_func(func); /* 就是声明一个委托对象，跟 student stu = new student(); 一样 */ this.invoke(dg,len,data); /* 在主线程里调用委托方法，这样在委托方法里上面的 invokerequired 就会为 false 了 */ } else } }}

C中委托应该定义在什么位置

3，C怎么定义一个委托把方法当参数传进去在线程里调用委托执行

线程的构造函数有Thread(ThreadStart) 和Thread(ParameterizedThreadStart) ，也就是说只支持这两种委托：public delegate void ThreadStart()和public delegate void ParameterizedThreadStart(Object obj)。对应的方法也就只能是类似的格式，如public void Haha()之类的。Thread th = new Thread(Haha);th.start();

搞不懂了。。既然是传方法：把那个类，或者窗体传进去可以么。先把那方法设为Public然后对象点方法名不就可以么

1，首先定义一个委托和类，其中DoSomeThing是线程要执行的方法： /// /// 定义委托 /// delegate void DelegateThreadFunction (); /// /// 线程类 /// class DelegateThread //委托对象 private DelegateThreadFunction threadFunction; /// /// 构造函数 /// /// public DelegateThread(DelegateThreadFunction threadFunction) this.threadFunction = threadFunction; } /// /// 执行线程函数 /// public void DoSomeThing() if (threadFunction

C怎么定义一个委托把方法当参数传进去在线程里调用委托执行

4，请问C中的委托是什么如何使用

直接看MSDN或网上搜的大部分说的都是比较生硬的术语，你可以通俗的理解为将一个方法作为参数传递给另一个方法！也可以理解为：现有N个参数和返回值都相同的方法，在使用的时候根据需要一个个调用太繁琐，干脆把这些方法的规律（方法参数和返回值）总结出来，定义成一个委托！然后把要执行的方法交给委托去执行！+=操作实际上就是委托链，委托一次代理了若干个方法，以后执行时，我们调用委托来执行，委托会把所代理的方法一个个再执行！委托在.net1.0就有，到了2.0时出现了匿名方法，也就是说委托要执行某一个方法，而这个方法并没有事先定义，随用随定义，连名字都没取，所以叫匿名方法。例：委托实例=delegate(int x,int y)到了.net3以后又更进一步，匿名方法还可以简写成：委托实例=(x,y)=>x+y; 这就是传说中的Lambda表达式，其本质是匿名方法，匿名方法本质是委托！先通俗理解后，再看文档，你会恍然大悟！委托、匿名方法、Lambda表达式的概念其实很重要，如果你不理解的话是没办法学习好LinQ的。这是我的理解，更多实例，你再搜吧~

你的理解基本没错.一般来说, 我们调用方法来完成某些工作, 传入的参数都是数据类型的, 委托可以认为是一个特殊的方法, 参数不是数据类型, 而是方法名, 实现的功能类似C++中的函数指针.你只要按书上的例子自己写一两个简单的委托来实现一小段功能就可以了, 这样可以对委托有一个大致的了解和知道怎么应用, 更深层的东西, 建议现在不要太过于深入了解, 等学习了后面的知识后, 再回头来看委托, 你的了解就自然会深入些.同样一本编程教材, 在你能力的不同阶段去看它, 都会有不同的领悟, 学习总是循序渐进的, 不要急于一次把委托吃透, 这不现实.

委托的用法很多:一般是用于声明事件和回调的委托,还可以是用于代表方法标签的委托.书本上的委托只是对委托的定义与具体怎样调用问题，没有涉及到委托的真正实用的地方。其实委托是与事件和回调一起来使用的，你可以看一下C#异步调用，与多线程处理里等就可以看到委托的作用了。下面是别人的理解我觉得还是比较好的：1)有了委托你就可以把方法看作像常数一样,而委托就是该常数类型的变量.从这个角度看来用于声明事件的委托就是声明这个事件触发以后所调用的方法的标签或者特征.只有符合该标签(参数个数和参数类型)的方法才可以做为该用于该事件的回调.一个事件触发了,你可能需要用多个方法处理该事件或者说该事件调用了多个方法(每个事件的实例都有一个需要调用的方法列表,当事件触发它会逐个调用列表中的每个方法)2)通过使用委托你可以实现对方法变化的封装.打个比方:如果你骑自行车,你需要有骑自行车的方法DriveBike().如果你骑摩托车你需要有骑摩托车的方法.现在你有一个方法DriveMoto.现在你需要定义一个方法,实现你骑(自行车或者摩托车)到某地DriveTo(地点,骑的方式)骑的方式这里其实就是委托.在使用的时候,如果你是骑自行车你就用DriveBike实例化委托的实例带入DriveTo方法,如果你骑摩托车你就用DriveMoto实例化"骑的方式"这个委托带入DriveTo方法.

委托是对方法的抽象，用来实现方法调用的解耦。就来事件为例，事件发表者并不会知道那个方法实现了这个事件的相应。而委托用类做为自己的底层实现，维护着一个委托的堆栈。

委托在C++里就是函数针指，定义了一个相同的函数入口，然后委托对函数抽象出来的结果事件由委托来实现的public delegate void EventHandle(object sender,eventArgs e);//定义委托public event EventHandle MyDIYEvent;//定义事件委托还有一个用法是异步

5，C用委托调用函数的步骤

命名方法：1.定义委托2.定义函数3.委托订阅函数例：public delegate void GetNum(); static GetNum gm; static void Main(string[] args) gm += Get; //订阅 } public static void Get() Console.WriteLine("成功订阅委托"); }匿名方法：1.定义委托2.委托订阅匿名函数例：public delegate void GetNum(); static GetNum gm; static void Main(string[] args) gm += delegate Console.WriteLine("成功订阅委托"); }; }

委托是c＃中的一种引用类型，类似于c/c++中的函数指针。与函数指针不同的是，委托是面向对象、类型安全的，而且委托可以引用静态方法和实例方法，而函数指针只能引用静态函数。委托主要用于 .net framework 中的事件处理程序和回调函数。一个委托可以看作一个特殊的类，因而它的定义可以像常规类一样放在同样的位置。与其他类一样，委托必须先定义以后，再实例化。与类不同的是，实例化的委托没有与之相应的术语(类的实例化称作对象)，作为区分我们将实例化的委托称为委托实例。函数指针一个函数在编译时被分配给一个入口地址，这个入口地址就称为函数的指针，正如同指针是一个变量的地址一样。函数指针的用途很多，最常用的用途之一是把指针作为参数传递到其他函数。我们可以参考下面的例子进一步理解函数指针作为参数的情况：# includeint max(int x,int y) { return (x>y?x:y); } int min(int x,int y) { return(xint sub(int x, int y) { return(x+y); } int minus(int x,int y) { return(x-y); } void test(int (*p)(int,int),int (*q)(int,int),int a,int b) { int int1,int2; int1=(*p)(a,b); int2=(*q)(a,b); printf("%d,\t%d\n",int1,int2); } void main() { test(max,min,10,3); test(sub,minus,10,3); } 客观的讲，使用函数指针作为其参数的函数如果直接调用函数或是直接把调用的函数的函数体放在这个主函数中也可以实现其功能。那么为什么还要使用函数指针呢？我们仔细看一下上面的main()函数就可以发现，main()函数两次调用了test函数，前一次求出最大最小值，后一次求出两数的和与差。如果我们test函数不用函数指针，而是采用直接在test函数中调用函数的方法，使用一个test函数还能完成这个功能吗？显然不行，我们必须写两个这样的test函数供main()函数调用，虽然大多数代码还是一样的，仅仅是调用的函数名不一样。上面仅仅是一个简单的例子，实际生活中也许main()函数会频繁的调用test()，而每次的差别仅仅是完成的功能不一样，也许第一次调用会要求求出两数的和与差，而下一次会要求求出最大值以及两数之和，第三次呢，也许是最小值和最大值，……，如果不用函数指针，我们需要写多少个这样的test()函数？显然，函数指针为我们的编程提供了灵活性。另外，有些地方必须使用到函数指针才能完成给定的任务，特别是异步操作的回调和其他需要匿名回调的结构。另外，像线程的执行，事件的处理，如果缺少了函数指针的支持也是很难完成的。类型安全从上面的介绍可以看出，函数指针的提出还是有其必要的，上面的介绍也同时说明了委托存在的必要性。那么为什么c＃中不直接用函数指针，而是要使用委托呢？这就涉及到另外一个问题：c＃是类型安全的语言。何谓类型安全？这里的类型安全特指内存类型安全，即类型安全代码只访问被授权可以访问的内存位置。如果代码以任意偏移量访问内存，该偏移量超出了属于该对象的公开字段的内存范围，则它就不是类型安全的代码。显然指针不属于类型安全代码，这也是为什么c＃使用指针时必须申明unsafe的缘故。那么类型不安全代码可能会带来什么不良的后果呢？相信对于安全技术感兴趣的朋友一定十分熟悉缓冲区溢出问题，通过缓冲区溢出攻击者可以运行非法的程序获得一定的权限从而攻击系统或是直接运行恶意代码危害系统，在unix下这是一个十分普遍的问题。那么缓冲区溢出又和函数指针有什么关系呢？事实上，攻击者就是通过缓冲区溢出改变返回地址的值到恶意代码地址来执行恶意代码的。我们可以看看下面的代码： void copy() { char buffer[128]; ........ strcpy (buffer,getenv("home"));//home为unix系统中的home环境变量 ........ } 上面的代码中如果home环境变量的字符数大于128，就会产生缓冲区溢出，假如这个缓冲区之前有另一个函数的返回地址，那么这一是地址就有可能覆盖，而覆盖这一地址的字符有可能就是恶意代码的地址，攻击者就有可能攻击成功了！上面的例子仅仅是指针问题中的一种，除此以外，还可能由于错误的管理地址，将数据写入错误地址，造成程序的崩溃；还可能由于对指针不恰当的赋值操作产生悬浮指针；还可能产生内存越界，内存泄漏等等问题。由此可见，指针不是类型安全的，函数指针当然也不例外，所以c＃里面没有使用函数指针，而且不建议使用指针变量。委托前面的说明充分证明了委托存在的必要性，那么我们再谈谈为什么委托是类型安全的。c＃中的委托和指针不一样，指针不通过msil而是直接和内存打交道，这也是指针不安全的原因所在，当然也是采用指针能够提高程序运行速度的缘故；委托不与内存打交道，而是把这一工作交给clr去完成。clr无法阻止将不安全的代码调用到本机（非托管）代码中或执行恶意操作。然而当代码是类型安全时，clr的安全性强制机制确保代码不会访问本机代码，除非它有访问本机代码的权限。委托派生于基类system.delegate，不过委托的定义和常规类的定义方法不太一样。委托的定义通过关键字delegate来定义： public delegate int mydelegate(int x,int y); 上面的代码定义了一个新委托，它可以封装任何返回为int，带有两个int类型参数的方法。任何一个方法无论是实例方法还是静态方法，只要他们的签名（参数类型在一个方法中的顺序）和定义的委托是一样的，都可以把他们封装到委托中去。这种签名方法正是保证委托是类型安全的手段之一。产生委托实例和产生类实例（对象）差不多，假如我们有如下的方法： public int sub(int x,int y) { return(x+y); } 我们就可以使用如下的代码得到一个委托实例： mydelegate calculatin=new mydelegate(sub); 接下来我们就可以直接使用calculation调用sub方法了： calculation(10,3); 下面我们将用委托重写上面的一个程序来看一下在c＃中如何通过委托实现由函数指针实现的功能： using system; class mathclass { public static int max(int a,int b) { return(a>b?a:b); } public static int min(int a,int b) { return(a public static int sub(int a,int b) { return (a+b); } public static int minus(int a,int b) { return (a-b); } } class handler { private delegate int calculation(int a, int b); private static calculation[] mycalculation=new calculation[2]; public static void eventhandler(int i,int a,int b) { switch (i) { case 1: mycalculation[0]=new calculation(mathclass.max); mycalculation[1]=new calculation(mathclass.min); console.writeline(mycalculation[0](a,b)); console.writeline(mycalculation[1](a,b)); break; case 2: mycalculation[0]=new calculation(mathclass.sub); mycalculation[1]=new calculation(mathclass.minus); console.writeline(mycalculation[0](a,b)); console.writeline(mycalculation[1](a,b)); break; default: return; } } } class test { static void main() { handler.eventhandler(1,10,3); handler.eventhandler(2,10,3); } }

文章TAG：定义一个委托什么定义一个委托 c 委托与事件定义在类里面还是类的外边