c#委托 订阅
C语言是一门面向过程的、抽象化的通用程序设计语言,广泛应用于底层开发。C语言能以简易的方式编译、处理低级存储器。C语言是仅产生少量的机器语言以及不需要任何运行环境支持便能运行的高效率程序设计语言。尽管C语言提供了许多低级处理的功能,但仍然保持着跨平台的特性,以一个标准规格写出的C语言程序可在包括类似嵌入式处理器以及超级计算机等作业平台的许多计算机平台上进行编译。 [1] 展开全文
C语言是一门面向过程的、抽象化的通用程序设计语言,广泛应用于底层开发。C语言能以简易的方式编译、处理低级存储器。C语言是仅产生少量的机器语言以及不需要任何运行环境支持便能运行的高效率程序设计语言。尽管C语言提供了许多低级处理的功能,但仍然保持着跨平台的特性,以一个标准规格写出的C语言程序可在包括类似嵌入式处理器以及超级计算机等作业平台的许多计算机平台上进行编译。 [1]
信息
类    别
程序设计语言
影响语言
C++、C#、D、Java、JavaScript、ObjectPHP等
创始时间
1972年
主要编译器
Visual C++、Clang、GCC、Turbo C等
中文名
C语言
创始人
Dennis MacAlistair Ritchie
发    源
BCPL语言
外文名
C Programming Language
c语言简介
C语言是一门面向过程的计算机编程语言,与C++、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。C语言描述问题比汇编语言迅速、工作量小、可读性好、易于调试、修改和移植,而代码质量与汇编语言相当。C语言一般只比汇编语言代码生成的目标程序效率低10%~20%。因此,C语言可以编写系统软件。 [2]  当前阶段,在编程领域中,C语言的运用非常之多,它兼顾了高级语言和汇编语言的优点,相较于其它编程语言具有较大优势。计算机系统设计以及应用程序编写是C语言应用的两大领域。同时,C语言的普适较强,在许多计算机操作系统中都能够得到适用,且效率显著。 [3]  冯.诺依曼在1945年提出了现代计算机的若干思想,被后人称为冯.诺依曼思想,这是计算机发展史上的里程碑。自1945 年至今大多采用其结构,因此冯.诺依曼被称为计算机之父。他的体系结构计算机由运算器、控制器、存储器、输入设备、输出设备五大部件构成。 C语言拥有一套完整的理论体系经过了漫长的发展历史,在编程语言中具有举足轻重的地位。 [4] 
收起全文
精华内容
参与话题
问答
  • C#委托总结以及案例

    千次阅读 2018-03-31 23:23:02
    C#委托1.委托就是把方法当做方法的参数来传递, 做自己不想做的事,是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。所有的委托都派生自System.Delegate类2. 委托的声明 Public delegate 返回...

    C#委托

    1.委托就是把方法当做方法的参数来传递做自己不想做的事,是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

    所有的委托都派生自System.Delegate

    2. 委托的声明

        Public delegate 返回类型 委托名称(要传递的参数)

    (1) 不带参数的委托

     

    (2) 带参数的委托

     

    3.委托的多播(Multicasting of a Delegate

    委托对象可使用 "+" 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。"-" 运算符可用于从合并的委托中移除组件委托。

    使用委托的这个有用的特点,您可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的 多播(multicasting),也叫组播。下面的程序演示了委托的多播:

     

     

    展开全文
  • C# 中的委托和事件(详解:简单易懂的讲解)

    万次阅读 多人点赞 2018-08-28 09:00:39
      本文转载自 ... C# 中的委托和事件(详解) https://www.cnblogs.com/newcapecjmc/p/7084026.html 基础:https://www.cnblogs.com/hongfei/p/3574239.html   中级...

     

     

    本文转载自 http://www.cnblogs.com/SkySoot/archive/2012/04/05/2433639.html

    C# 中的委托和事件(详解)

    https://www.cnblogs.com/newcapecjmc/p/7084026.html

    基础:https://www.cnblogs.com/hongfei/p/3574239.html

     

    中级:http://www.tracefact.net/tech/009.html

    https://blog.csdn.net/yijun494610095/article/details/62422746

     

    进阶:https://www.cnblogs.com/sjqq/p/6917497.html

     

    关于委托和事件分享三个博客内容:

    首先说明下:

    (1)C#中事件:事件时属于类的成员,所以要放在类的内部。

    (2)委托属于一个定义,是和类、接口类似的,通常放在外部。

    (因为大多数委托都要被重用)

    委托定义在类里面还是类外面视情况而定,一般定义在与类定义平级部分,

    且用public修饰,便于外部调用。

    若定义在类的内部,则必须通过调用该类的成员才能取得其委托的引用,

    频繁调用的情况下不合适。

    *委托定义在类内部,举例说明如下:

    Class A {
      //声明在这里是可以的~
      private delegate void test_del(int a);
      
      private void test(){...}

      public void start(){
        //声明在这里就不行了~
        private delegate void test_del(int a);
      }
    }

     

    委托是一种特殊的类,和普通类不同的是委托是对一类方法的抽象。

    因此只能在类内部定义内部类(包括委托、结构和枚举)而不能在方法中定义

     

     

    第一个:

    再谈C#委托与事件

     

    转自:http://ruizhinet.blog.163.com/blog/static/9921382820092801032681/

    之前写过一篇关于C#委托与事件的文章(见《C#委托和事件例析》),不过还是收到一些网友的提问。所以,今天再换另一个角度来详解一下这个问题。

    一、在控制台下使用委托和事件

    我们都知道,C#中有“接口”这个概念,所谓的“接口”就是定义一套标准,然后由实现类来具体实现其中的方法,所以说“接口,是一组类的抽象”。同样道理,我们可以将“委托”理解为“方法的抽象”,也就是说定义一个方法的模板,至于这个方法具体是怎么样的,就由方法自己去实现。

    我们知道接口的最大好处就是可以实现多态,同理,“委托”是可以实现方法的多态,当我们想调用某个具体方法的时候,我们不直接调用这个方法,而是去调用这个委托。当然,我们必须在具体方法和委托之间建立某种关联。

    下面我们来看例子。

    首先,我们定义一个委托:

    public delegate void SaySomething(string name);

    这跟抽象方法的语法格式很相似,只是多了一个关键字delegate。既然是对方法的一种抽象,那么我们最关注的当然就是方法的返回值以及方法的参数了。所以上面红色的部分就是我们定义出来的一个规矩,如果某个方法想委托我去做事,那么请你遵循我的规矩,就是返回值为void,参数为一个字符串。我们这个委托的含义是,当某个人来了,就向他说点东西。

    好,既然我们已经定义了这个规矩,下面我们就定义具体的方法了。

    public void SayHello(string name) {     Console.WriteLine("Hello," + name + "!"); }

    public void SayNiceToMeetYou(string name) {     Console.WriteLine("Nice to meet you," + name + "!"); }

    我们这里一共定义了两个方法,一个是向某人说Hello,另一个是向某人说Nice to meet you。我们看到,这里定义的两个方法的返回值和参数跟我们前面定义的“委托”是一致的。

    接下来,我们来看事件。

    public event SaySomething come;

    我们定义了一个事件,这个事件是“有人来了”,注意定义的时候我们使用event关键字,除此之外,我们还加上了前面定义的“委托”的名字。这个意思是说,我这个事件只会跟“SaySomething”打交道,并且,当我这个事件发生的时候,我会通知关注我的这些“委托”(再由这些“委托”去调用具体的方法)。

    我们来定义一个测试方法:

    public void test() {      SaySomething sayhello = new SaySomething(SayHello);     SaySomething saynice = new SaySomething(SayNiceToMeetYou);     come += sayhello;     come += saynice;     come("张三"); }

    方法体中的前面两行是用来实例化委托,注意我们用到了new关键字,就好像实例化一个类一样,然后传入一个参数,但这个参数不是string类型、也不是int类型,而是一个方法名。

    再下面两行就是将委托加到事件上,意思是说,如果你这个事件发生了,就告诉我一声。可以通过“+=”来将n个委托实例加到某个事件上,一旦这个事件发生,所有的这些委托实例都会得到通知。

    最后一行是触发一个事件,注意我们是直接用一个事件名,然后跟一个参数,这又跟“委托”中定义的那个规矩一致(即,要有一个string类型的参数)。

    最后运行一下

    static void Main(string[] args) {     Program program = new Program();     program.test();     Console.Read(); }

    我们回过头来再看一下“事件”的定义:

    public event SaySomething come;

    这里已经指出了“委托”的名字,所以,我们可以直接将方法加到事件上,而省略“委托”的实例化过程,因此上面的test()方法可以简单写为:

    public void test() {      come += SayHello;     come += SayNiceToMeetYou;     come("张三"); }

     

    二、在窗体中使用委托和事件

    上面的例子并不能体现委托和事件的优点,其实,委托和事件在C#中使用非常广泛,例如,当我们点击某个“按钮”的时候,就会有一个“Click”事件触发,而这个事件会通知“委托”,在C#窗体应用程序中,“委托”的名字比较规范,统一使用“EventHandler”,它的具体格式是“void EventHandler(object sender, EventArgs e);”。相信大家都写过下面这样子的HelloWorld程序:

    当点击按钮的时候弹出一个对话框。我们怎样实现的呢?你肯定会说,我们在设计窗口双击按钮,就会自动为我们生成类似如下的方法:

    private void button1_Click(object sender, EventArgs e) {     MessageBox.Show("我被点击了!!!"); }

    其实,这里用到的就是事件和委托,这里的button1_Click就是符合EventHandler委托规矩的一个具体的方法,即返回值为void,参数分别是一个object和EventArgs。

    我们可以在Form1.Designer.cs中看到如下代码:

    this.button1.Click += new System.EventHandler(this.button1_Click);

    可以看到,这里有一个Click事件,然后将一个委托实例附加到这个事件上,跟我们前面讲的控制台应用程序中的用法是完全一样的。那这个Click事件是怎么触发的呢?对于这些系统类的事件,并不用我们管。

    当然,我们也可以定义自己的事件和委托,例如我定义一个事件,这个事件就是输出对象的名字。

    我们这里定义了一个ShowName委托和一个btnclick事件。并且,在button1_Click()方法中触发这个btnclick事件。最后的结果是,当我们点击按钮的时候,首先弹出一个“我被点击了!!!”的对话框,然后确定之后再弹出另一个显示按钮名称的对话框:

     

    第二个 

    C#委托和事件例析  

    ah_bill是对Java了解相对较多,而对C#则是因工作需要才去看了一下,C#跟Java在语法上非常相似,而最初让我比较困惑的就是委托、事件部分,相信大多数初学者也有类似的困惑。经过跟Java的对比学习,发现这其实跟Java的监听、事件是等同的,只是表述上不同罢了。

    委托+事件是观察者模式的一个典型例子,所谓的委托其实就是观察者,它会关心某种事件,一旦这种事件被触发,这个观察者就会行动。

    下面是最近写的一个例子,相信能够加深大家对委托和事件的理解。

    using System; using System.Collections.Generic; using System.Text;

    namespace ConsoleApplication3

    {    

    public delegate void TimeEventHandler(object obj, TimeEventArgs  args); //定义一个委托,委托其实就是“方法模板”,就好像“类”是“对象”的模板一样。如果某个类想在事件触发的时候收到通知,它必须有一个符合这种格式的方法,在这个例子中,就是:返回类型为void,参数类型为object、TimeEventArgs。

    //TimeEventArgs是我们自己定义的一个类,用于保存事件中的参数。这里我们分别保存时间的时分秒。

        public class TimeEventArgs:EventArgs

           {        

                   private int hour;        

                   private int minute;

                   private int second;        

                   public TimeEventArgs(int hour, int minute, int second)       

                     {            

                             this.hour = hour;            

                             this.minute = minute;            

                             this.second = second;      

                   }        

                 public int Hour        

                 {            

                             get           

                            {                

                                 return hour;            

                          }        

               }        

              public int Minute        

                        {            

                              get            

                               {                

                                 return minute;            

                              }        

                       }        

             public int Second        

                      {            

                            get            

                            {                

                              return second;        

                           }        

                    }    

    }

     //这是一个观察者类,它有一个符合我们上面定义的“委托”的方法,也就是void ShowTime(object obj, TimeEventArgs args),从这个方法的定义可以看到,我们只会关心返回类型和方法的参数,而方法名称则无所谓。

       class MyTimeEventHandlerClass    

      {        

             public void ShowTime(object obj, TimeEventArgs args)        

             {            

                   Console.WriteLine("现在的时间是:"+args.Hour+":"+args.Minute+":"+args.Second);        

             }    

    }

    //时钟类     class Clock    

                 {

    //我们在这个类中定义了一个“TimeChanged”事件,注意其前面有两个关键字“event”和“TimeEventHandler”,其中event表示这是一个事件,而不是方法或属性;TimeEventHandler则指出,谁要监听TimeChanged事件,它就必须有一个符合TimeEventHandler(委托)的方法。        

                            public event TimeEventHandler TimeChanged;        

                            public Clock()        

                            {            

                                    TimeChanged = null; //注意,这里的null的含义是指TimeChanged事件当前还没有观察者关注它,如果某个观察者要关注TimeChanged事件,它必须要让这个事件知道,方法是使用操作符“+=”来借助委托将其加载到事件上。        

                            }

    //时钟开始走动,我们的目标是每秒钟触发一次TimeChanged事件        

                         public void go()        

                          {            

                                    DateTime initi = DateTime.Now;            

                                    int h1 = initi.Hour;            

                                    int m1 = initi.Minute;            

                                    int s1 = initi.Second;            

                                    while (true)            

                                     {                

                                          DateTime now = DateTime.Now;                

                                          int h2 = now.Hour;                

                                          int m2 = now.Minute;                

                                          int s2 = now.Second;                

                                            if (s2!=s1)                

                                              {                    

                                                   h1 = h2;                    

                                                   m1 = m2;                    

                                                    s1 = s2;

    //首先建立一个TimeEventArgs对象来保存相关参数,这里是时分秒。                    

    TimeEventArgs args = new TimeEventArgs(h2,m2, s2);

    //注意这种写法,这一句是用来触发事件,事件不是类,所以不用使用“new”关键字,而且我们看到,这里TimeChanged的两个参数跟我们的委托(TimeEventHandler)是一致的,其中第一个参数是触发这个事件的对象,我们这里使用的是一个时钟实例(this)。

                                                  TimeChanged(this, args);             

                                             }            

                                    }        

                           }    

               }

     

        class Program    

        {

            static void Main(string[] args)        

            {            

                     Clock clock = new Clock(); //实例化一个时钟            

                     MyTimeEventHandlerClass tehc = new MyTimeEventHandlerClass(); //实例化一个观察者类

    //将事件跟我们定义的观察者进行连接,这样,clock就会知道,每当TimeChanged事件被触发,就会去通知这个观察者,注意我们连接的时候使用的并不是直接的观察者类实例中的ShowTime()方法,而是一个委托,并在这个委托中传递ShowTime()方法,这也是“委托”的真正意义所在——我有一个方法,但我委托你来帮我关联到事件,因为事件只会直接跟委托打交道,而不是观察者的具体某个方法。            

                      clock.TimeChanged+=new TimeEventHandler(tehc.ShowTime);            

                      clock.go();        

           }    

        }

    }

    第三个博文:

    C#中的委托到底是什么概念??

    委托,简单理解是这样的.
    比如您要管您的孩子,把孩子送进了幼儿园.
    OK.此时您就把您的孩子委托给了幼儿园.
    当幼儿园放学,将孩子交还给您的手中.则是委托的回调.
    当然我这里的例子是说异步委托调用.您也可以同步.
    什么是同步委托调用?
    您去银行存钱.把钱给柜员.他们帮你点钞.存款然后给您存折或卡.
    那么您就相当于把钱委托给了柜员让他去执行存钱的这个函数.
    明白了么?

    Delegate
    delegate是C#中的一种类型,它实际上是一个能够持有对某个方法的引用的类。与其它的类不同,delegate类能够拥有一个签名(signature),并且它"只能持有与它的签名相匹配的方法的引用"。它所实现的功能与C/C++中的函数指针十分相似。它允许你传递一个类A的方法m给另一个类B的对象,使得类B的对象能够调用这个方法m。但与函数指针相比,delegate有许多函数委托和事件在 .Net Framework中的应用非常广泛指针不具备的优点。首先,函数指针只能指向静态函数,而delegate既可以引用静态函数,又可以引用非静态成员函数。在引用非静态成员函数时,delegate不但保存了对此函数入口指针的引用,而且还保存了调用此函数的类实例的引用。其次,与函数指针相比,delegate是面向对象、类型安全、可靠的受控(managed)对象。也就是说,runtime能够保证delegate指向一个有效的方法,你无须担心delegate会指向无效地址或者越界地址。

    实现一个delegate是很简单的,通过以下3个步骤即可实现一个delegate:
    1. 声明一个delegate对象,它应当与你想要传递的方法具有相同的参数和返回值类型。
    2. 创建delegate对象,并"将你想要传递的函数作为参数传入"。
    3. 在要实现异步调用的地方,通过上一步创建的对象来调用方法。
    using System;

    public class MyDelegateTest
    {
    // 步骤1,声明delegate对象
    public delegate void MyDelegate(string name);

    // 这是我们欲传递的方法,它与MyDelegate具有相同的参数和返回值类型
    public static void MyDelegateFunc(string name)
    {
    Console.WriteLine("Hello, ", name);
    }
    public static void Main()
    {
    // 步骤2,创建delegate对象(实例??)
    MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
    // 步骤3,调用delegate
    md("sam1111");
    }
    }
    输出结果是:Hello, sam1111

    了解了delegate,下面我们来看看,在C#中对事件是如何处理的。

    C#中的事件处理实际上是一种具有特殊签名的delegate,象下面这个样子:
    public delegate void MyEventHandler(object sender, MyEventArgs e);
    其中的两个参数,sender代表事件发送者,e是事件参数类。MyEventArgs类用来包含与事件相关的数据,所有的事件参数类都必须从System.EventArgs类派生。当然,如果你的事件不含参数,那么可以直接用System.EventArgs类作为参数。

    就是这么简单,结合delegate的实现,我们可以将自定义事件的实现归结为以下几步:
    1.定义delegate对象类型,它有两个参数,第一个参数是事件发送者对象,第二个参数是事件参数类对象。
    2.定义事件参数类,此类应当从System.EventArgs类派生。如果事件不带参数,这一步可以省略。
    3.定义"事件处理方法,它应当与delegate对象具有相同的参数和返回值类型"。
    4.用event关键字定义事件对象,它同时也是一个delegate对象。
    5.用+=操作符添加事件到事件队列中(-=操作符能够将事件从队列中删除)。
    6.在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说,此方法应为protected访问限制,既不能以public方式调用,但可以被子类继承。名字是OnEventName。
    7. 在适当的地方调用事件触发方法触发事件。

    下面是一个简单的例子:

    using System;
    public class EventTest
    {
    // 步骤1,定义delegate对象
    public delegate void MyEventHandler(object sender, System.EventArgs e);
    // 步骤2(定义事件参数类)省略
    public class MyEventCls
    {
    // 步骤3,定义事件处理方法,它与delegate对象具有相同的参数和返回值类型
    public void MyEventFunc(object sender, System.EventArgs e)
    {
    Console.WriteLine("My event is ok!");
    }
    }
    // 步骤4,用event关键字定义事件对象
    private event MyEventHandler myevent;
    private MyEventCls myecls;
    public EventTest()
    {
    myecls = new MyEventCls();
    // 步骤5,用+=操作符将事件添加到队列中
    this.myevent += new MyEventHandler(myecls.MyEventFunc);
    }
    // 步骤6,以调用delegate的方式写事件触发函数
    protected void OnMyEvent(System.EventArgs e)
    {
    if(myevent != null)
    myevent(this, e);
    }
    public void RaiseEvent()
    {
    EventArgs e = new EventArgs();
    // 步骤7,触发事件
    OnMyEvent(e);
    }
    public static void Main()
    {
    EventTest et = new EventTest();
    Console.Write("Please input ''a'':");
    string s = Console.ReadLine();
    if(s == "a")
    {
    et.RaiseEvent();
    }
    else
    {
    Console.WriteLine("Error");
    }
    }
    }
    输出结果如下,红色为用户的输入:
    Please input ‘a’: a
    My event is ok!

    展开全文
  • C# 讲解委托和事件的好文章集合。 包括: C# 委托妙文 C# 委托和事件 C# 委托使用方法 C# WndProc的使用方法 文档内有详细代码,您一定可以用它学会委托和事件!
  • c#委托(Delegates)--基本概念及使用

    万次阅读 多人点赞 2018-05-13 00:10:56
    在我这菜鸟理解上,委托就是可以用方法名调用另一方法的便捷方法,可以简化switch等语句的重复。最近做项目的时候恰好需要用到委托,便来复习及学习委托的使用。嗯...本人以前并没有用过,只是稍微知道而已。以下是...


       在我这菜鸟理解上,委托就是可以用方法名调用另一方法的便捷方法,可以简化switch等语句的重复。最近做项目的时候恰好需要用到委托,便来复习及学习委托的使用。嗯...本人以前并没有用过,只是稍微知道而已。以下是整理的笔记。

    一.委托的概念

        委托是用户自定义的类,它定义了方法的类型。储存的是一系列具有相同参数和返回类型方法的地址列表,调用委托时,此委托列表的所有方法都将被执行。

    二.委托类型的定义

    委托类型必须在被用来创建变量以及类型对象之前声明。

    委托类型的声明:

    1.以delegate关键字开头。

    2.返回类型+委托类型名+参数列表

    delegate void MyDel(int a)

    三.实例

    1)现在我们先创建了控制台程序,进行简单的实例

    namespace Func
    {
        public delegate void MyDel();//声明一个自定义委托
        class Program
        {
            static void Main(string[] args)
            {
                MyDel say1 = SayHi;
                MyDel say2 = new MyDel(SayHi);
                say1();
                say2();
            }
            static void SayHi()
            {
                Console.WriteLine("hi");
            }
        }
    }

    2)扩展实例

    namespace Func
    {
        public delegate int MyDel(int num);//声明一个自定义委托
        class Program
        {
            static int Add1(int a)
            {
                int b = 10 + a;
                Console.WriteLine("——Add1———");
                return b;
    
            }
    
            static int Add2(int a)
            {
                int b = 10 - a;
                Console.WriteLine("——Add2———");
                return b;
    
            }
    
            static void Calculate(MyDel ex, int a)
            {
                var result = ex(a);
                Console.WriteLine(result + "\n");
            }
    
            static void Main(string[] args)
            {
                Calculate(Add1, 1);
                Calculate(Add2, 10);
                Console.ReadKey();
            }
        }
    }

    结果如下图


    上面实现了把方法当作参数在另一个方法中传递或调用”;从上面可以看出,调用的方法和委托的返回类型,参数类型都必须一致。

    我们可以把委托作为参数传递给封装好了的方法,通过委托来动态的调用方法。


    四.委托的加减运算

    可以使用+=运算符,为委托新增方法。

    同样可以使用-=运算符,为委托移除方法。

    当委托列表中有几个方法时,调用委托时,则会依次经过各个方法,并返回列表最后一项方法的结果。

    namespace Func
    {
        public delegate int MyDel(int num);//声明一个自定义委托
        class Program
        {
    
            static int Add1(int a)
            {
                int b = 10 + a;
                Console.WriteLine("——Add1———");
                return b;
    
            }
    
            static int Add2(int a)
            {
                int b = 10 - a;
                Console.WriteLine("——Add2———");
                return b;
    
            }
    
            static void Calculate(MyDel ex, int a)
            {
                var result = ex(a);
                Console.WriteLine(result + "\n");
            }
    
            static void Main(string[] args)
            {
                //Calculate(Add1, 1);
                //Calculate(Add2, 10);
                MyDel myDel = Add1;
                myDel += Add2;
                Calculate(myDel, 10);
                Console.ReadKey();
            }
        }
    }

    结果如下图:



    那么有时候我们需要返回每个方法的结果,此方法就不适用了,那怎么才能实现每个方法的返回结果都可以获取到呢?后续再写了。今天就简单的介绍了委托的基本概念和使用。


    展开全文
  • c#里面委托(delegate)的讲解

    万次阅读 2018-01-28 19:41:20
    c#里面,有的时候一些代码的实现必须用到委托,比如:线程里面修改某个textBox的值,如果直接在线程里面写修改的代码,执行时候,编译器会报错,因为c#不允许这样写。还有在单独写的类里面,修改某个form里面某个...

           在c#里面,有的时候一些代码的实现必须用到委托,比如:线程里面修改某个textBox的值,如果直接在线程里面写修改的代码,执行时候,编译器会报错,因为c#不允许这样写。还有在单独写的类里面,修改某个form里面某个控件的属性值等等,也是不被允许的。这时候,就需要使用到委托(delegate)。委托其实是这样的,为某些实现写一个函数,并将其赋值给委托(相当于函数指针),在使用 的时候直接通过委托名来调用。

    声明和定义委托分为4个步骤:


    1.声明一个委托(函数指针)

    2. 创建委托对象

    3. 创造符合委托格式的函数。(指针指向的函数)
    4. 将函数名称赋值给委托。
    下面是一个简单的例子:
    我使用vs2013新建了一个windows窗体应用程序,默认新建的窗口名字为Form1,双击窗口进入form1的代码编写页面,如图:
    接下来进行第1步+第2步:委托的声明和委托对象的定义(要写在与form1的默认构造函数并列的位置)
    然后在form1里面拖入两个控件,一个是button1,一个是label1,现在自己写一个函数reFresh(),用来修改label1的text,这就是
    第3步创造符合委托格式的函数。然后在form1_load里面进行第4步将函数名称赋值给委托。如图:
    接下来的步骤是我自己写的一个调用,我自己写了一个类dele(不知道怎么自定义写类的自行百度),内容如下:
    现在开始写button1的函数,让我们可以运行出执行完的效果;函数内容如下:
    然后就可以开心的运行了;以下是运行截图,点击button1一次,就会实现label1数据的一次自增;
    下面是我对代码的粘贴,试验的时候可以自行拷贝;
    Form1.cs:
    namespace Delegate
    {
        public partial class Form1 : Form
        {
            public delegate void RefreshLable();  //委托的声明,我取的名字是RefreshLable,返回值类型自主定义;
            public RefreshLable refL1;   //创建委托对象;
            public Form1()
            {
                InitializeComponent();
            }
            int i = 0;     //声明一个int值,用来作为文本框的值;
            public void reFresh()   //创造符合委托格式的函数。(i自增,在文本框里显示);
            {
                i++;
                label1.Text = i.ToString();
            }
            private void Form1_Load(object sender, EventArgs e)
            {
                refL1 = reFresh;  //将函数名称赋值给委托;
                dele.frm = this;  //这句是一定要写的,用来告诉编译器dele类里的对象frm指的是这个from1;
            }
            private void button1_Click(object sender, EventArgs e)
            {
                dele de = new dele();   //实例化一个dele类的对象;
                de.useDelegate();     //调用类的函数,实现委托的使用;
            }
        }
    }
    
    dele.cs
    public class dele
        {
            public static Form1 frm;    //定义一个from类的对象;
            public void useDelegate()  //写这个函数,来调用委托;
            {
                frm.Invoke(frm.refL1);    //调用委托一定得使用这种方式;
            }
        }
    

    展开全文
  • Csharp委托详解

    千次阅读 2018-05-24 23:41:34
    using System; using System.Collections.Generic;...namespace Csharp委托和事件详解 { /* * 作者:Ai * 时间:2018.3.1 * * ps:委托和事件我已经学习了好几遍了,但隔得时间长了总是又忘记, ...
  • C#委托(Delegate)精讲

    2020-06-15 21:54:35
    前言:C#中的委托类似于C或C++中函数的指针。委托是存有对某个方法的引用的一种引用类型变量,引用可在运行时被改变。 文章目录一、委托的概念二、声明委托 一、委托的概念 委托类型表示对具有特定参数列表和返回...
  • C#委托

    千次阅读 热门讨论 2014-12-14 16:32:03
    刚开始在C#视频中就看到了委托,到了大话中首先还是看这些基础知识,对于委托我始终不太理解,因此我就上网查了一些资料并且结合自己的理解,来介绍一下委托。  【汉语】  把事情托付给别人或别的机构。  ...
  • C#委托 C#委托 C#委托

    2010-06-24 08:30:55
    C#委托 C#委托 C#委托C#委托 C#委托
  • C# 委托 (一)—— 委托、 泛型委托与Lambda表达式

    万次阅读 多人点赞 2018-08-19 20:46:47
    1 委托的含义 2 委托声明、实例化和调用 2.1 委托的声明 2.2 委托的实例化 2.3 委托实例的调用 3 泛型委托 3.1 Func委托 3.2 Action委托 3.3 Predicate委托 4 匿名委托 5 Lambda表达式 5.1 表达式Lambda ...
  • 本人做的一个非常简单 C#委托的例子,很基础很简单的一个小例子,最最适合委托初学者参看。再结合资料,相信学通C#委托不是一件难事。 委托很好的解决了窗体之间的数据传递和方法调用,非常实用,通过这个例子相信能...
  • 委托(delegate)是一种存储函数引用的类型。这听起来相当深奥,但其机制是非常简单的。委托的声明非常类似于函数,但不带函数体,且要使用delegate 关键字。委托的声明制定了一个返回类型和一个参数列表。 定义了...
  • C#委托使用

    千次阅读 2019-05-23 14:42:26
    C#委托使用案例 委托的使用 假定有两个对象A和B,在A中实例化了对象B,那么A可以访问B中的方法,反过来B不能直接访问A中的方法,所以使用委托。 委托的使用步骤:条件(在A对象中实例化了B) (1)、在B中声明一...
  • C#委托与事件

    2018-04-17 19:29:36
    C#委托与事件一、委托(C#中的委托就是C++中的回调函数)记得在使用C语言的年代,整个项目中都充满着针指的身影,那时候流行使用函数指针来创建回调函数,使用回调可以把函数回调给程序中的另一个函数。但函数指针...
  • C#委托和事件的概念

    千次阅读 2018-10-10 14:26:41
    一、事件的本质 事件是软件系统里的两个子系统之间,或者两个模块之间,或者两个对象之间发送消息,并处理消息的过程。在面向对象的世界里,就可以统一认为是两个对象之间的行为。 两个对象之间发送的这种消息,对...
  • C#委托-委托和事件(来自张子阳)

    千次阅读 2010-11-21 23:53:00
    引言 <br />委托 和 事件在 .Net Framework中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没有过去的...
  • C# 委托

    2017-10-26 09:46:39
    C# 委托实际上类似于C++中的函数指针,因为C#中不存在指针,所以用委托可以完成一些原来在C++中用函数指针完成的操作,例如传递一个类A的方法m给另一个类B的对象,使得类B的对象能够调用这个方法m。但与函数指针相比,...
  • 委托 委托是一个类,它定义了方法的类型,使得可以将方法当作另一个方法的参数来进行传递。事件是一种特殊的委托委托是方法的抽象,它存储的就是一系列具有相同签名和返回类型的方法的地址。调用委托的时候,委托...
  • 最近遇到了一些C#委托相关的问题,貌似理解了,去写的时候又不知为何,所以就去查了些相关文章去了解,下面写下我的理解 首先什么是委托?菜鸟教程上是这样说的:C# 中的委托(Delegate)类似于 C 或 C++ 中函数的...
  • C# 委托(delegate)和事件(event)详解

    万次阅读 多人点赞 2017-10-11 17:26:08
    C# 中的委托和事件 引言 委托 和 事件在 .Net Framework中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没有过去...
  • C#委托及事件

    千次阅读 2011-09-09 16:34:00
    C#中,委托(delegate)是一种引用类型,在其他语言中,与委托最接近的是函数指针,但委托不仅存储对方法入口点的引用,还存储对用于调用方法的对象实例的引用。 简单的讲委托(delegate)是一种类型安全的函数...
  • 实现功能描述: ... UI设计: 主窗体:拖放两个Label:label1和lblCounter,label1的Text属性设置为“从窗体被点击次数:”,lblCounter的Text属性设置为“0”。从窗体:拖放一个Button:...【1】声明委托 ...
  • C#委托及事件委托的理解

    千次阅读 2006-12-14 11:01:00
    委托的声明public delegate void MyDelegate(string str);注1.委托的定义和方法的定义类似,只是在前面加了一个delegate,但委托不是方法,它是一种类型。是一种特殊的类型,看成是一种新的对象类型比较好理解。用于对...
  • [unity3d]unity中C#委托的应用

    万次阅读 多人点赞 2014-01-18 01:42:36
    C#中有一种还是挺实用的类型,就是...下面我就从参考网上的一个例子,讲解一下unity中C#委托的应用。 我们新建一个脚本,取名TestDelegate。这个主要的功能就是点击中文按钮输出中文名字,点击英文按钮输出英文名字。
  • C# 委托及Lambda 表达式

    2019-04-19 17:36:36
    Delegate 委托 委托声明:public delegate int MyDelegate (string s); 用delegate关键字定义委托,它是对特定返回类型和参数的方法的抽象,是你定义的一种新数据类型,它与int、class是一样的都是数据类型。符合...
  • C# 委托(二)—— 多播委托与事件

    千次阅读 2018-09-01 19:47:35
    1 多播委托 1.1 多播委托的实例化 1.2 多播委托的调用与返回结果 1.3 多播委托的逐个调用 2 事件 2.1 事件的本质 2.2 事件用法三步曲 2.3 事件与多播委托的区别 上一篇文章中,介绍了委托的基本用法(传送门...
  • C#委托之个人理解,并附有实例,使你看了以后受益匪浅!!!
  • C#委托和事件

    2018-05-22 09:32:57
     委托C#第一个版本就引入的特性,特点如下 1. 类似于C++中的函数指针; 2. 允许方法像变量一样赋值; 3. 用以作回调操作; 4. 委托以链表的方式记录委托实例; 5. 委托实例中使用的类型并不需要与委托声明中...
  • C# 委托的作用

    千次阅读 2018-07-05 10:56:51
    首先,委托的关键字是Delegate ,委托是和类同级别的对象,委托应该声明成Public。下面我们先来看下这段代码: public delegate int GreetingDelegate(int a ,int b);//定义委托 static void Main(string[] args) ...
  • 使用最新的visual studio 2019编写的winform计算器,采用委托技术实现,用来练手的好项目,欢迎大家下载

空空如也

1 2 3 4 5 ... 20
收藏数 289,016
精华内容 115,606
关键字:

c#委托

c# 订阅