C#事件

事件详情

事件的应用


事件都是被动触发的，当被用到的时候才会被触发

闪电标记的就是事件成员
扳手标记的是属性
方块标记的是方法

一颗星的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System;
using System.Windows.Forms;

namespace event2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //事件拥有者
            Form form = new Form();
            //事件响应者
            Controller controller = new Controller(form);
            form.ShowDialog();
        }
    }

    class Controller
    {
        private Form form;

        public Controller(Form form)
        {
            if (form != null)
            {
                this.form = form;
                //click为事件，事件订阅
                this.form.Click += this.formClicked;
            }
        }

        //通过对象方法去绑定事件
        private void formClicked(object sender, EventArgs e)
        {
            this.form.Text = DateTime.Now.ToString();
        }
    }
}

两颗星

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Windows.Forms;

namespace event3
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //事件拥有者和事件响应者为一体
            myForm myForm = new myForm();
            //事件
            myForm.Click += myForm.FormClicked;
            myForm.ShowDialog();
        }
    }

    internal class myForm : Form
    {
        //事件处理器
        internal void FormClicked(object sender, EventArgs e)
        {
            this.Text = DateTime.Now.ToString();
        }
    }
}

三颗星(应用最广泛)

事件拥有者是事件响应者的一个字段，成员，事件响应者用自己的方法订阅自己成员的某个事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using System;
using System.Windows.Forms;

namespace event4
{
    internal class Program
    {
        static void Main(string[] args) {
            MyForm myForm = new MyForm();
            myForm.ShowDialog();
        }
    }

    class MyForm : Form
    {
        public TextBox textBox;
        public Button button;

        public MyForm()
        {
            this.textBox = new TextBox();   
            this.button = new Button();
            this.button.Text = "点击";
            this.button.Top = 23;
            this.Controls.Add(textBox);
            this.Controls.Add(button);
            //事件绑定
            this.button.Click += this.buttonClicked;
        }
        //事件处理
        private void buttonClicked(object sender, EventArgs e)
        {
            this.textBox.Text = DateTime.Now.ToString();
        }
    }
}

其它



这里sender类似于js中的event对象，就是当前执行的方法的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using System;
using System.Windows.Forms;

namespace windowApp
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            //delegate声明一个匿名函数，这里也可以改为箭头函数
            this.button3.Click += delegate (object sender, EventArgs e)
            {
                this.box.Text = "33333";
            };
        }

        private void Btn_Click(object sender, EventArgs e)
        {
            if (sender == this.button1)
            {
                this.box.Text = "你好";
            }
            if (sender == this.button2)
            {
                this.box.Text = "hello";
            }
        }

        private void Form1_Load(object sender, EventArgs e) { }
    }
}

其他按钮的事件已经在窗口属性那里添加了，都是为Btn_Click方法
和js添加事件的操作差不多

wpf

使用的xaml去修饰页面

事件的声明


声明自定义事件
事件是基于委托的，事件需要一个委托类型，来做一个约束，这个约束即规定了事件能够发送什么样的消息给事件的响应者，这就决定了事件响应值的事件处理器，必须能够跟这个约束匹配上，它才能够订阅上这个事件

完整声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EventDet
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //事件拥有者
            Customer customer = new Customer();
            //事件响应者
            Waiter waiter = new Waiter();
            //事件及其绑定事件处理器
            customer.Order += waiter.Action;
            customer.action();
            customer.PayTheBill();
            Console.ReadLine();
        }
    }

    internal class Waiter
    {
        internal void Action(Customer customer, OrderEventArgs e)
        {
            Console.WriteLine("服务员将给-{0}-上菜", e.DishName);
            double price = 10;
            switch (e.Size)
            {
                case "small":
                    price = price * 0.5;
                    break;
                case "large":
                    price = price * 1.5;
                    break;
            }
            customer.Bill += price;
        }
    }
	//继承EventArgs这个类是规范化处理
    public class OrderEventArgs : EventArgs
    {
        public string DishName { get; set; }
        public string Size { get; set; }
    }
    //委托类
    public delegate void OrderEventHandler(Customer customer, OrderEventArgs e);

    public class Customer
    {
        //定义委托
        private OrderEventHandler orderEventHandler;
        //基于委托定义事件value为外部+=右边的东西，通过这里的事件，会将方法和当前委托绑定
        public event OrderEventHandler Order
        {
            add { this.orderEventHandler += value; }
            remove { this.orderEventHandler -= value; }
        }

        public double Bill { get; set; }

        public void PayTheBill()
        {
            Console.WriteLine("i will pay ${0}", Bill);
        }
        //通过委托类去触发方法
        public void action()
        {
            if (orderEventHandler != null)
            {
                OrderEventArgs e = new OrderEventArgs();
                e.DishName = "小明";
                e.Size = "large";
                //触发委托的方法
                orderEventHandler(this, e);
            }
        }
    }
}

delegate 相当于定义一个函数类型。
event 相当于定义一个 delegate 的函数指针（回调函数指针）。

简略声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace eventDel
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //事件拥有者
            Customer customer = new Customer();
            //事件响应者
            Waiter waiter = new Waiter();
            //事件及其绑定事件处理器
            customer.Order += waiter.Action;
            customer.action();
            customer.PayTheBill();
            Console.ReadLine();
        }
    }

    internal class Waiter
    {
        internal void Action(Customer customer, OrderEventArgs e)
        {
            Console.WriteLine("服务员将给-{0}-上菜", e.DishName);
            double price = 10;
            switch (e.Size)
            {
                case "small":
                    price = price * 0.5;
                    break;
                case "large":
                    price = price * 1.5;
                    break;
            }
            customer.Bill += price;
        }
    }

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

    public delegate void OrderEventHandler(Customer customer, OrderEventArgs e);

    public class Customer
    {
        //定义事件
        public event OrderEventHandler Order;

        public double Bill { get; set; }

        public void PayTheBill()
        {
            Console.WriteLine("i will pay ${0}", Bill);
        }

        public void action()
        {
            if (Order != null)
            {
                OrderEventArgs e = new OrderEventArgs();
                e.DishName = "小明";
                e.Size = "large";
                Order(this, e);
            }
        }
    }
}

总结

三个普通类

  1. 事件拥有者类
    1. 上述代码中的Customer类
  2. 事件响应者类
    1. 上述代码中的Waiter类
  3. 传递信息类
    1. 上述代码中的OrderEventArgs类
      一个委托类
      上述代码中的OrderEventHandler类
      事件是对委托的一种封装机制