C# 事件

已于 2022-10-15 15:51:33 修改
阅读量2.1k 收藏 6
点赞数
分类专栏： C# 文章标签： c# 开发语言
于 2022-10-15 11:21:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39354845/article/details/127331841
版权

一、简介

（非常感谢刘铁猛老师免费视频，让我本来对事件的认识加深了很多）

event ,能够发生的东西，事件的触发必须由事件的拥有者来触发

事件的功能就是： 通知+ 可选的事件参数

事件模型：

1、事件的拥有者（event source  对象） ---事件的源头

2、事件的成员 event 成员      事件本身，----通知功能

3、事件的响应者 event subscribe 对象

4 、事件的处理器 本质上是事件响应者的一个方法回调方法   eventhandler 

5、事件的订阅   把事件处理器和事件关联到一起，可以理解是一种以 委托的约定

 

二、windows 的事件

一个很简单的例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;

namespace 委托和事件Like
{
     class EventExample
    {
        static void Main(string[] args)
        {
            //1、 timer 是事件的拥有者
            Timer timer = new Timer();
            timer.Interval = 1000;

            // 3、事件的 响应者 是Boy 这个对象类
            Boy boy = new Boy();
            Girl girl = new Girl(); 
            // 5、事件订阅
            timer.Elapsed += boy.Action;
            timer.Elapsed+=girl.Action;
            // 2 、事件本身就是    timer.Elapsed 通知功能
            timer.Start();
            Console.ReadLine();
        }


    }



    class Boy
    {

        // 4、事件处理器
        internal void Action(object sender, ElapsedEventArgs e)
        {
            Console.WriteLine(" Boy      sssssssssssss");
        }
    }


    class Girl
    {

        // 4、事件处理器
        internal void Action(object sender, ElapsedEventArgs e)
        {
            Console.WriteLine("Girl ---sssssssssssss");
        }
    }
}

一星事件模型：委托和父子窗口通信

B点击窗口--》A显示数据

B窗口：也是是事件源头

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 委托和父子窗口通信
{
    public partial class B : Form
    {

        //1、 委托的定义
        public delegate void ChangedTextDelegate(String s);

        //2、 声明一个事件  事件本身 通知功能
        public  static   event  ChangedTextDelegate ChangedTextevent;
        public B()
        {
            InitializeComponent();
        }
         // 事件的拥有者
        private void button1_Click(object sender, EventArgs e)
        {
            string aa = "B------>A";
            if(ChangedTextevent != null)
            {
                ChangedTextevent(aa);
            }
        }
    }
}

A 窗口：也就是事件的响应者 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 委托和父子窗口通信
{
    public partial class A : Form
    {

        // 事件的响应者
        public A()
        {
            
            InitializeComponent();
            B f2 = new B();
            f2.Show();

            //  B.ChangedTextevent  就是事件本身 起一个通知的功能 =====2
            //  mychangeText 是对B中事件的响应
            //5 、在A中订阅B中的委托的事件
            B.ChangedTextevent += new B.ChangedTextDelegate(mychangeText);
        }

        //4 、响应事件
        public void mychangeText(string s)
        {
            this.textBox1.Text = s;
        }

        private void button1_Click(object sender, EventArgs e)
        {

        }
    }

}

 二星事件

 

三星： 事件的拥有者是事件的一个字段成员


    public partial class MyForm : Form
    {
        public MyForm()
        {
            InitializeComponent();

            // 事件的源头是事件的一个字段 就是button1 这个字段


           // 事件的订阅
            this.button1.Click += this.Button1myClick;
        }

        private void Button1myClick(object sender, EventArgs e)
        {
            this.textBox1.Text = "hell world !!!";
        }
    }

然后我们可以做一个相互控制的程序： 

 A:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using static 委托和父子窗口通信.B;

namespace 委托和父子窗口通信
{

    //1、 委托的定义
    public delegate void ChangedTextA2BDelegate(String s);

    //2、 声明一个事件  事件本身 通知功能
    

    public partial class A : Form
    {
        public static event ChangedTextA2BDelegate ChangedTextA2Bevent;
        // 事件的响应者
        public A()
        {
            this.Text = "A";
            InitializeComponent();
            B f2 = new B();
            f2.Show();

            //  B.ChangedTextevent  就是事件本身 起一个通知的功能 =====2
            //  mychangeText 是对B中事件的响应
            //5 、在A中订阅B中的委托的事件
            B.ChangedTextevent += new ChangedTextDelegate(mychangeText);
        }

        //4 、响应事件
        public void mychangeText(string s)
        {
            this.textBox1.Text = s;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string aa = "A------>B";
            if (ChangedTextA2Bevent != null)
            {
                ChangedTextA2Bevent(aa);
            }
        }

        private void A_Load(object sender, EventArgs e)
        {

        }
    }


}

B：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 委托和父子窗口通信
{
    //1、 委托的定义
    public delegate void ChangedTextDelegate(String s);
    public partial class B : Form
    {



        //2、 声明一个事件  事件本身 通知功能
        public  static   event  ChangedTextDelegate ChangedTextevent;
        public B()
        {  
            InitializeComponent();
            A.ChangedTextA2Bevent += new ChangedTextA2BDelegate(mychangeText);
        }

        public void mychangeText(string s)
        {
            this.textBox1.Text = s;
        }

        // 事件的拥有者
        private void button1_Click(object sender, EventArgs e)
        {
            string aa = "B------>A";
            if(ChangedTextevent != null)
            {
                ChangedTextevent(aa);
            }
        }

        private void B_Load(object sender, EventArgs e)
        {

        }
    }
}

三、自定义事件

自定义完整的事件声明方式：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace 委托和事件Like
{
     class EventDefine
    {
        static void Main(string[] args)
        {

            Constomer constomer    =new Constomer();
            Waiter waiter = new Waiter();
            constomer.Order += waiter.Action;
            constomer.MyAction();
            constomer.PayBill();
            Console.ReadLine();
        }


    }
    public delegate void  OrderEventhandler(Constomer c, OrderEventArgs e);
    public class OrderEventArgs:EventArgs
    {
        public string   DishName  { get; set; }
        public string  Size { get; set; }
    }

    public class  Constomer
    {
        private OrderEventhandler orderhandle;
        public event OrderEventhandler Order
        {
            add
            {
                orderhandle += value; 
            }
            remove  
            {
                orderhandle -= value;
            }
        }


        public double    Bill { get; set; }

        public  void  PayBill()
        {
            Console.WriteLine("I will pay ${0}",this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into the  restarent. ");
        }

        public void SitDown()
        {
            Console.WriteLine("SitDown. ");
        }

        public void Think()
        {
            Console.WriteLine("Think. ");
            Thread.Sleep(5000);
            // 如果orderhandle 是空的表示没人订阅
            if (this.orderhandle!=null)
            {
                OrderEventArgs e=new OrderEventArgs();
                e.DishName = "沙拉酱";
                e.Size = "large";
                orderhandle.Invoke(this,e);
            }
        }

        public void  MyAction()
        {
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

    public class Waiter
    {
        internal void Action(Constomer c, OrderEventArgs e)
        {
            Console.WriteLine("Waiter:        I will serve you the  dish- {0}", e.DishName);
            double price = 10;
            switch(e.Size)
            {
                case "small":
                    price = price * 0.7;
                     break;
                case "middle":
                    price = price * 1;
                    break;
                case "large":
                    price = price * 1.3;
                    break;
            }
            c.Bill+=price;
        }
    }
}

事件的简化声明：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace 委托和事件Like
{
     class EventDefine
    {
        static void Main(string[] args)
        {

            Constomer constomer    =new Constomer();
            Waiter waiter = new Waiter();
            constomer.Order += waiter.Action;
            constomer.MyAction();
            constomer.PayBill();
            Console.ReadLine();
        }


    }
    public delegate void  OrderEventhandler(Constomer c, OrderEventArgs e);
    public class OrderEventArgs:EventArgs
    {
        public string   DishName  { get; set; }
        public string  Size { get; set; }
    }

    public class  Constomer
    {
        //private OrderEventhandler orderhandle;
        //public event OrderEventhandler Order
        //{
        //    add
        //    {
        //        orderhandle += value; 
        //    }
        //    remove  
        //    {
        //        orderhandle -= value;
        //    }
        //}

        public  event OrderEventhandler Order;


        public double    Bill { get; set; }

        public  void  PayBill()
        {
            Console.WriteLine("I will pay ${0}",this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into the  restarent. ");
        }

        public void SitDown()
        {
            Console.WriteLine("SitDown. ");
        }

        public void Think()
        {
            Console.WriteLine("Think. ");
            Thread.Sleep(5000);
            // 如果orderhandle 是空的表示没人订阅
            if (this.Order != null)
            {
                OrderEventArgs e=new OrderEventArgs();
                e.DishName = "沙拉酱";
                e.Size = "large";
                Order.Invoke(this,e);
            }
        }

        public void  MyAction()
        {
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

    public class Waiter
    {
        internal void Action(Constomer c, OrderEventArgs e)
        {
            Console.WriteLine("Waiter:        I will serve you the  dish- {0}", e.DishName);
            double price = 10;
            switch(e.Size)
            {
                case "small":
                    price = price * 0.7;
                     break;
                case "middle":
                    price = price * 1;
                    break;
                case "large":
                    price = price * 1.3;
                    break;
            }
            c.Bill+=price;
        }
    }
}

简单声明的主要地方 

 //private OrderEventhandler orderhandle;
        //public event OrderEventhandler Order
        //{
        //    add
        //    {
        //        orderhandle += value; 
        //    }
        //    remove  
        //    {
        //        orderhandle -= value;
        //    }
        //}

        public event OrderEventhandler Order;

将事件中的event 去掉

  // 假如我们吧这里的event 字段去掉  这个就是一个委托了，程序运行，但是会有一个bug 

事件的触发必须由事件的拥有者来触发

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace 委托和事件Like
{
    class EventDefine
    {
        static void Main(string[] args)
        {

            Constomer constomer = new Constomer();
            Waiter waiter = new Waiter();
            constomer.Order += waiter.Action;
            OrderEventArgs e1 = new OrderEventArgs();
            e1.DishName = "mashaji";
            e1.Size = "large";
            OrderEventArgs e2 = new OrderEventArgs();
            e2.DishName = "niupai";
            e2.Size = "large";

          //  constomer.MyAction();

            Constomer badgay = new Constomer();
            badgay.Order += waiter.Action;
            badgay.Order.Invoke(constomer,e1);
            badgay.Order.Invoke(constomer, e2);
          
            constomer.PayBill();
            Console.ReadLine();
        }


    }
    public delegate void OrderEventhandler(Constomer c, OrderEventArgs e);
    public class OrderEventArgs : EventArgs
    {
        public string DishName { get; set; }
        public string Size { get; set; }
    }

    public class Constomer
    {
        //private OrderEventhandler orderhandle;
        //public event OrderEventhandler Order
        //{
        //    add
        //    {
        //        orderhandle += value; 
        //    }
        //    remove  
        //    {
        //        orderhandle -= value;
        //    }
        //}


         // 假如我们吧这里的event 字段去掉  这个就是一个委托了，程序运行
       // public event OrderEventhandler Order;
        public  OrderEventhandler Order;

        public double Bill { get; set; }

        public void PayBill()
        {
            Console.WriteLine("I will pay ${0}", this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into the  restarent. ");
        }

        public void SitDown()
        {
            Console.WriteLine("SitDown. ");
        }

        public void Think()
        {
            Console.WriteLine("Think. ");
            Thread.Sleep(5000);
            // 如果orderhandle 是空的表示没人订阅
            if (this.Order != null)
            {
                OrderEventArgs e = new OrderEventArgs();
                e.DishName = "沙拉酱";
                e.Size = "large";
                Order.Invoke(this, e);
            }
        }

        public void MyAction()
        {
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

    public class Waiter
    {
        internal void Action(Constomer c, OrderEventArgs e)
        {
            Console.WriteLine("Waiter:        I will serve you the  dish- {0}", e.DishName);
            double price = 10;
            switch (e.Size)
            {
                case "small":
                    price = price * 0.7;
                    break;
                case "middle":
                    price = price * 1;
                    break;
                case "large":
                    price = price * 1.3;
                    break;
            }
            c.Bill += price;
        }
    }
}

 

 改正： 

 

 只需要改这里就可以l

 public class Constomer
    {
        //private OrderEventhandler orderhandle;
        //public event OrderEventhandler Order
        //{
        //    add
        //    {
        //        orderhandle += value; 
        //    }
        //    remove  
        //    {
        //        orderhandle -= value;
        //    }
        //}


         // 假如我们吧这里的event 字段去掉  这个就是一个委托了，程序运行
        public event OrderEventhandler Order;
        //public  OrderEventhandler Order;

        public double Bill { get; set; }

        public void PayBill()
        {
            Console.WriteLine("I will pay ${0}", this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into the  restarent. ");
        }

        public void SitDown()
        {
            Console.WriteLine("SitDown. ");
        }

事件： 事件是对委托字段的一个包装器，只能是在 订阅上面“+=”或者“-=”

 

常用事件中我们一般不适用自定义的委托，经常适用windows 自己提供的 EventHandle 做为 一个基础的使用：

      // 假如我们吧这里的event 字段去掉  这个就是一个委托了，程序运行
        public event EventHandler Order;

对 EventArgs的改造：


    public class Waiter
    {
        internal void Action(Object sender, EventArgs e)
        {
            Constomer c = sender as Constomer;
            OrderEventArgs orderinfo = e as OrderEventArgs;
            Console.WriteLine("Waiter:        I will serve you the  dish- {0}", orderinfo.DishName);
            double price = 10;
            switch (orderinfo.Size)
            {
                case "small":
                    price = price * 0.7;
                    break;
                case "middle":
                    price = price * 1;
                    break;
                case "large":
                    price = price * 1.3;
                    break;
            }
            c.Bill += price;
        }
    }

全部程序：



using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace 委托和事件Like
{
    class EventDefine
    {
        static void Main(string[] args)
        {

            Constomer constomer = new Constomer();
            Waiter waiter = new Waiter();
            constomer.Order += waiter.Action;
              constomer.MyAction();
            constomer.PayBill();
            Console.ReadLine();
        }


    }
   // public delegate void OrderEventhandler(Constomer c, OrderEventArgs e);
    public class OrderEventArgs : EventArgs
    {
        public string DishName { get; set; }
        public string Size { get; set; }
    }

    public class Constomer
    {

        public event EventHandler Order;

        public double Bill { get; set; }

        public void PayBill()
        {
            Console.WriteLine("I will pay ${0}", this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into the  restarent. ");
        }

        public void SitDown()
        {
            Console.WriteLine("SitDown. ");
        }

        public void Think()
        {
            Console.WriteLine("Think. ");
            Thread.Sleep(5000);
            // 如果orderhandle 是空的表示没人订阅
            if (this.Order != null)
            {
                OrderEventArgs e = new OrderEventArgs();
                e.DishName = "沙拉酱";
                e.Size = "large";
                Order.Invoke(this, e);
            }
        }

        public void MyAction()
        {
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

    public class Waiter
    {
        internal void Action(Object sender, EventArgs e)
        {
            Constomer c = sender as Constomer;
            OrderEventArgs orderinfo = e as OrderEventArgs;
            Console.WriteLine("Waiter:        I will serve you the  dish- {0}", orderinfo.DishName);
            double price = 10;
            switch (orderinfo.Size)
            {
                case "small":
                    price = price * 0.7;
                    break;
                case "middle":
                    price = price * 1;
                    break;
                case "large":
                    price = price * 1.3;
                    break;
            }
            c.Bill += price;
        }
    }
}

最终代码：


using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace 委托和事件Like
{
    class EventDefine
    {
        static void Main(string[] args)
        {

            Constomer constomer = new Constomer();
            Waiter waiter = new Waiter();
            constomer.Order += waiter.Action;
            constomer.MyAction();
            constomer.PayBill();
            Console.ReadLine();
        }


    }
    public class OrderEventArgs : EventArgs
    {
        public string DishName { get; set; }
        public string Size { get; set; }
    }

    public class Constomer
    {

        public event EventHandler Order;

        public double Bill { get; set; }

        public void PayBill()
        {
            Console.WriteLine("I will pay ${0}", this.Bill);
        }

        public void WalkIn()
        {
            Console.WriteLine("Walk into the  restarent. ");
        }

        public void SitDown()
        {
            Console.WriteLine("SitDown. ");
        }

        public void Think()
        {
            Console.WriteLine("Think. ");
            Thread.Sleep(5000);
            this.OnOrder("messi","large");
        }


        // 触发事件
        protected void OnOrder(string dishName,string size)
        {
                        // 如果orderhandle 是空的表示没人订阅
            if (this.Order != null)
            {
                OrderEventArgs e = new OrderEventArgs();
                e.DishName = dishName;
                e.Size = size;
                this.Order.Invoke(this, e);
            }
        }

        public void MyAction()
        {
            this.WalkIn();
            this.SitDown();
            this.Think();
        }
    }

    public class Waiter
    {
        internal void Action(Object sender, EventArgs e)
        {
            Constomer c = sender as Constomer;
            OrderEventArgs orderinfo = e as OrderEventArgs;
            Console.WriteLine("Waiter:        I will serve you the  dish- {0}", orderinfo.DishName);
            double price = 10;
            switch (orderinfo.Size)
            {
                case "small":
                    price = price * 0.7;
                    break;
                case "middle":
                    price = price * 1;
                    break;
                case "large":
                    price = price * 1.3;
                    break;
            }
               c.Bill += price;
        }
    }
}

总结：

 

 

Σίσυφος1900
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中关于事件的讲解
qq_58155240的博客
03-23 523
C#中的事件声明以及使用
C#学习（10）-----事件
m0_62976227的博客
12-04 1848
一、事件的基本概念 事件是什么呢？他是一个东西，得能够发生，发生了就会给其他的东西通知。 事件是类的成员。它使类或对象具有通知别的类或对象的能力。 而当然，不仅仅有通知。 有些事件，例如说手机响铃，会伴随着其他的消息，比如谁谁谁领导通知你开会，家人跟你聊天什么的。这种伴随着事件传达的信息称为事件参数。 手机响铃会有很多种可能，而有些事件，其发生与通知本身就蕴含了一些信息，没有必要再给你其他的事件参数。比如红灯停绿灯行。 因而，事件的功能=通知+可选的事件参数。它用与类或对象之间的动作协调与信息传
C#写一个windows消息推送通知
最新发布
一个专注于技术研究创新的程序员
04-28 224
【代码】C#写一个windows消息推送通知。
C#中的事件
讲述工作、生活、技术中的日常与感悟。
01-26 276
前言 大家好，我是阿辉。 在我们日常的软件开发工作中，很容易用到事件机制，简单举例就好比民国时期订阅报纸机制一样，当订阅者在报社订阅该报社发行的报纸一样，只需要告诉报社快递到哪里即可，每次当报社发报时，订阅人都会在同一时间地点收到订阅的报纸，不会出现遗漏等情况。 这也就是编程过程中事件所要解决问题。 那么我们一起来学习下在C#语言下，事件到底该如何实现？ 什么是事件 以前在设计模式学习的过程中，了解到了订阅者/发布者模式，它解决的是当一个特定事件程序发生时，程序的其它部分得到该事件已经发生的通知。 在这种模
C#事件机制
三品的博客
03-30 272
事件是类或对象的成员，用于通知其它类或对象发生的相关事情。其也是一种对现实事物逻辑关系的抽象。
C# 事件（Event）用法
weixin_41883890的博客
08-05 3559
任何现有的事件订阅者都是遵循经典模式的事件的订阅者。第二个参数：e是EventArgs类型 EventArgs类表示包含事件数据的类的基类，并提供用于不包含事件数据的事件的值。一个对象要想被作为事件监听器，需要将该对象中的事件处理程序 注册(或挂载)到另一个能够产生事件的对象（即事件源）上，这样会导致事件源必须保持一个到事件侦听器对象的引用，以便在事件发生时调用此侦听器的处理方法。这很合理，但如果这个引用是一个 强引用，则监听器会作为事件源的一个依赖 从而不能作为垃圾回收，即使引用它的对象是事件源。...
C#实现类似QQ的任务栏通知窗口
10-10
http://blog.csdn.net/u010484683/article/details/12497307 这个链接例子对应的可运行解决方案！ 从右下角弹出小窗口，2秒后自动缩回去消失关闭，主窗体在这个过程不会失去焦点，因为用了P/Invoke平台调用！弹出的小窗体还可以根据图片改变形状（不规则窗体！），还可以拖动，关闭！小程序大功能！
改进C#代码之25：用事件模式实现通知
weixin_34194702的博客
08-18 131
  事件提供了一种标准的机制来通知监听者。.NET的事件模式使用了事件语法来实现观察者模式。任意数量的客户对象都可以将自己的处理函数注册到事件上，然后处理这些事件。这些客户对象不需要再编译期就给出。时间也不必非要有订阅者才能正常工作。在C#中使用事件可以降低发送者和可能的通知接受者之间的耦合。发送者可以完全独立于接收者进行开发。事件是实现广播类型行为信息的标准方式。      下面按照使用场景...
C# 事件（Event）
abc800868的博客
05-17 196
C# 事件（Event） 事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些出现，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。事件是用于进程间通信。 通过事件使用委托 事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。包含事件的类用于发布事件。这被称为 发布器（publisher） 类。其...
C#学习笔记（十四）事件（一）通知
xiaoyaolangwj的博客
04-07 1479
定义： 定义：单词：Event，翻译为“事件”。 《牛津词典》中的解释：“a thing that happens, especially something important”。 通顺的解释就是：能够发生的什么事情。 如果一个作为主语的名词可以使用发生这个词来作为的他的谓语动词的话，那么这个名词就是个事件。 举个栗子：拿苹果作为主语，谓语动词就不能是发生。但如果是苹果新机发布，或者说苹果公司上市作为主语的话，他们都是可以发生的，也就是说他们都是事件。也就是说是以公司为主体的上市，和以新机为..
C#事件实例详解
01-20
C#事件实例详解 C#和JAVA有许多相似的地方，设计思想差不多，语法及其相像，均传承自面向对象设计思想，灵感来自C++并取其精华去其“糟粕（二字持保留意见）”，中间语言、解释执行、一次编译、到处执行，出身豪门算...
C#事件编程
05-15
C#语言编程中，最常用的，最有效的使用，事件的编程实例
C#事件
01-06
简单来说，要想理解事件，必先理解委托。只要委托明白了，事件也就自然而然的明白了。 事件和委托是连在一起的，我大概列一下： （1）委托是事件的类型。前一篇文章我说过，委托可以看作是一个类，那么事件就是这个...
C#事件Demo
01-05
通过一个带有欢迎界面的窗体demo，讲解自定义事件的使用方法
c# 事件传值
02-26
使用事件传值是不同form之间共享数据，并同时更改不同form显示内容。
windows消息常量值
qqwhhh的博客
09-17 794
WM_NULL = 0 WM_CREATE = 1 应用程序创建一个窗口 WM_DESTROY = 2 一个窗口被销毁 WM_MOVE = 3 移动一个窗口 WM_SIZE = 5 改变一个窗口的大小 WM_ACTIVATE = 6 一个窗口被激活或失去激活状态； WM_SETFOCUS = 7 获得焦点后 WM_KILLFOCUS = 8 失去焦点 WM_ENABLE = 10 改变enable状态 WM_SETREDRAW = 11 设置窗口是否能重画 WM_SETTEXT = 12 应用程序发送此消息
C#中事件
Jeffxu_lib的博客
01-04 7590
一、事件基础 1、事件简介 事件常用于对某一消息作出的反应。当某一事件被触发之后，就会对其做出对应的响应。 连接消息和反馈动作的符号为+=，符号左侧表示发出的消息，右侧表示对消息做出的响应函数 2、事件提示及查看 在输入对象加点号后，VS会出现智能提示，其分别代表： 小扳手：表示属性 立方体：表示函数或方法 闪电：表示事件 二、常见事件示例 1、定时器事件Timer 要包含对应的命名空间：using System.Timers; 指定时间间隔，然后每到指定的间隔就响应一次，代码如下：
C# 事件(event)
熊思雨的博客
05-30 5185
事件是一种特殊的多播委托，仅可以从声明事件的类（或派生类）或结构（发布服务器类）中对其进行调用。如果其他类或结构订阅该事件，则在发布服务器类引发该事件时，将调用其事件处理程序方法可以将事件标记为publicprivateprotectedinternal或。这些访问修饰符定义该类的用户访问该事件的方式。事件在我们平时开发中用的还是比较多的，大部分时候用在框架中，比如 Winform 中的 Timer 组件，如下面代码，Timer.Elapsed 就是一个事件//实例化Timer类，
c#事件
05-31
C# 事件是一种特殊的委托，用于在对象之间传递消息或通知。它允许一个对象在特定条件下触发事件，而其他对象可以注册并处理这个事件。C# 事件的语法如下： ``` public delegate void EventHandler(object sender, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值