经典实例:父窗体与子控件的相互调用
这里先复习一下父类和继承子类的相互调用.
class Program
{
static void Main(string[] args)
{
Student student = new Student() {
Age = 9, GradeName = "四年级" };
// 子类可直接调用父类非同名成员
student.SayHello();// Show:我是Person,大家好
// 子类通过转化父类型访问父同名方法
((Person)student).SayHi();// Show:我是person,9岁
// 父类通过里氏转换调用子类成员(即虚方法实现多态):该person前提是student
Person person = (Person)student;
student.SayHi(); // Show:我是Student,在四年级
Console.Read();
}
}
public class Person
{
public int Age {
get; set; }
public void SayHello()
{
Console.WriteLine($"我是Person,大家好");
}
public virtual void SayHi()
{
Console.WriteLine($"我是person,{Age}岁");
}
}
public class Student : Person
{
public string GradeName {
get; set; }
public new void SayHi()// override重写/new隐藏父类方法
{
Console.WriteLine($"我是Student,在{GradeName}");
}
}
然后,考虑父窗体和子控件如何相互调用成员
父窗体调用子控件很简单:
应用场景, 父窗体刷新的时候,让子控件的列表数据也刷新一下.
public class FormA
{
public void Load()
{
ControlB controlB = new ControlB();
FormA.Panel1.Add(controlB);
// 因为子控件B为A的成员,只要将它的成员改为public,即可直接调用
formA.controlB.FuncB();
}
}
public class ControlB
{
public void FuncB() {
Console.WriteLine("做了一堆事情"); }
}
子控件如何调用父窗体成员:
应用场景:子控件保存数据后,希望父窗体内的列表刷新一下.
杀马特写法:
public class FormA
{
public void Load()
{
ControlB controlB = new ControlB(this);// 把自己传过去,就可以让子控件直接使用了
FormA.Panel1.Add(controlB);
}
public void FuncA() {
Console.WriteLine("做了两堆事情"); }
}
public class ControlB
{
FormA formBoss;
public ControlB(FormA formA)
{
formBoss = formA;
}
public void DoSomethingAfterSaved()
{
formBoss.FuncA();// 父窗体某个刷新
}
}
委托正常写法(包含委托的理解)
子控件的委托=我的方法
namespace ConsoleApp5
{
public delegate void DeleFunc();// 我是一个没参数的委托类型
public class FormA
{
public void Load()
{
ControlB controlB = new ControlB();
FormA.Panel1.Add(controlB);
controlB.deleF = FuncA;// (我把方法甩(委托)给你了,你咋用都行,别烦我了)
}
public void FuncA() {
Console.WriteLine("做了两堆事情"); }
}
public class ControlB
{
public DeleFunc deleF;// 我这个委托实体,已被别人赋值了一套方法
public void DoSomethingAfterSaved()
{
// 保存后,调用父窗体的刷新的
deleF(); deleF(); deleF(); deleF(); deleF();// 别人给我的,我可以随意劳役这个方法
}
}
}
所以为什么使用委托:我们访问不到的类,想使用他的方法(饭),可以给他一个委托(碗),让他把方法赋值给委托(把饭盛到碗里),这个委托(碗)是引用类型,我和你都访问到.
委托的别的用法(委托(方法的载体)作为参数)
public class ClassA
{
public void Load()
{
DeleFunc deleF;// 我这个委托实体
ClassB cb = new ClassB();
deleF = cb.FuncA;// (你把方法甩(委托)给我了,什么时候用取决于我)
cb.Do(deleF);// 你喝什么由我做主
}
}
public class ClassB
{
public void Do(DeleFunc funcRandom)
{
Console.WriteLine("我好无聊,不知道该干啥.老弟,你来安排我");
funcRandom();
Console.WriteLine("喝饱了,回家");
}
public void FuncA() {
Console.WriteLine("我端起了一杯水,做了一些事喝了的方法"); }
public void FuncB() {
Console.WriteLine("我起了一瓶酒,喝了的方法"); }
}
所以为什么使用委托：在我们编写程序的时候，程序的上下文是固定的，在某个关键的部分，不确定调用哪个函数，这时候需要让程序更换被调用函数，又不想两个函数耦合性太高，使用委托可实现间接调用，或者可替换调用.
有了委托了,特别方便了.但是为什么还要有事件,是委托有什么缺点么?
为什么要有事件?
看下面的例子
namespace 为什么使用事件
{
public delegate void deleClick();
class Sanlianji : Button // 定义一个可以点三下的按钮
{
int i = 0;
//public event deleClick dc;
public deleClick dc;
protected override void OnClick(EventArgs e)// 按钮点三下后, 开始执行别人传过来的委托(即点三下后,程序员想让我弄啥嘞)
{
i++;
if (i == 3)
{
//执行委托
dc();
i = 0;
}
}
}
}
namespace 为什么使用事件
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
sanlianji1.dc= func;// 点三下后,把func(点三下要做的事,赋值给委托),然后就实现了:点三下,弹出"你点击了三下特殊的按钮"
}
private void func()
{
MessageBox.Show("你点击了三下特殊的按钮");
}
private void button1_Click(object sender, EventArgs e)
{
// 虽说实现了我们想要的功能,可是如果我们拉个普通按钮,直接调用委托(委托是公开的,啥时候谁想掉谁调用)如下
sanlianji1.dc();// 出问题了,人家点三下才能弹出提示的美女(自定义按钮的功能),被一个猪(系统按钮)给拱了.还有可能被千千万万的猪任何时候都给拱了.
}
}
}
如上,所以我们做出来的委托,只想在我们想要的情况下调用,不能瞎调乱调, 因此,微软给我们弄了一个event关键词,在声明委托实体的时候加上event这个标志,就说明,这个委托比较害羞,藏在屋子里,外面的人想要给她沟通,必须按她的规矩来,通过+=赋值,-=取消委托
代码调整如下
namespace 为什么使用事件
{
public delegate void deleClick();
class Sanlianji : Button
{
int i = 0;
public event deleClick dc;// 加上event后,就变成了事件(特殊的委托,不能随意=(盗用),只能通过+=(赋值)或-=(取消委托))
protected override void OnClick(EventArgs e)
{
i++;
if (i == 3)
{
//执行委托
if(dc!=null)// 可以通过这么写,来得到什么时候我们三点击是否会执行方法的效果
{
dc();
}
i = 0;
}
}
}
}
namespace 为什么使用事件
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
sanlianji1.dc = func;// 报错;通过赋值的方式赋值事件(特殊委托),不行了
sanlianji1.dc += func;// 只能通过+=赋值了
}
private void func()
{
MessageBox.Show("你点击了三下");
}
private void button1_Click(object sender, EventArgs e)
{
sanlianji1.dc();// 报错;通过直接调用事件(特殊委托),不行了
}
}
}
事件是什么样子的?
用我们经常见到事件的窗体举例
首先,系统命名了一个很标准的两参委托类型EventHandler
然后,系统定义了一个事件,规定了啥时候触发,啥时候调用这个委托
然后是赋值如下,
this.button1.Name = "button1";
// 右侧是正常的委托或者方法,左侧是事件,左侧限制了只有button1被点击了才能展示运行我们+=赋值的方法.
this.button1.Click += new System.EventHandler(this.button1_Click);
this.button1.Click += this.button1_Click;//这样也行的,方法赋值给委托嘛
所以，事件三小模块（都以按钮单击为例）
0.声明委托类型，创建委托实例（如上两张图）
1.调用体（什么时候调用）
如控制台Main方法中调用，按钮单击底层判断if（双击）{写逻辑和调用体}，或者我们自己的代码中写调用体
写法：
//…其他逻辑代码…
if (Click!=null)
{
Click();
}
//…其他逻辑代码…
2.执行内容体(符合单击条件后执行什么内容)
public void button1_Click(object sender，EventArgs e)
{
//…执行的个人代码逻辑内容…
}
3.事件赋值体（-=取消事件）
this.button1.Click += new System.EventHandler(this.button1_Click);
this.button1.Click += this.button1_Click;
而常见窗体事件，再双击后，仅需写执行内容体即可。
那日常生活中,事件怎么使用呢,我们怎么制造某种情况的事件呢
看下面这个例子:
namespace 委托与事件
{
public delegate void CatShotEventHandler();// 委托类型
class Program
{
static void Main(string[] args)
{
Cat cat = new Cat("Tom");
Mouse mouse1 = new Mouse("Jerry");
Mouse mouse2 = new Mouse("Jack");
// 以下两行是事件赋值体
cat.CatShot += new CatShotEventHandler(mouse1.Run);// 猫来了,老鼠要做的事儿
cat.CatShot += new CatShotEventHandler(mouse2.Run);//
cat.shout();// 正常调用,以下两行是委托例子，不用看
// CatShotEventHandler dele_catShout = new CatShotEventHandler(cat.shout);// 定义了一个正常的委托,赋值的方法为:猫来了
//dele_catShout();// 调用这个委托方法,猫来了.方法内,如果已经给事件赋值,就执行赋值的方法,不执行.
Console.ReadKey();
}
//static void cat_CatShot()
//{
// throw new NotImplementedException();
//}
}
class Cat
{
private string name;
public Cat(string name)
{
this.name = name;
}
// 定义了一个事件(其实啊,就是定义了一个特殊的委托变量:特殊是指:不能随意=(盗用),只能通过+=(赋值)或-=(取消))
public event CatShotEventHandler CatShot;
public void shout()//调用体
{
Console.WriteLine("喵喵,我是{0}",name );
// 平时只是猫来,老鼠做什么不知道, 只有后来赋值了事件方法,猫来老鼠才逃.工作中的例子.平时双击的时候,我们想让系统执行我们造的特殊方法,但是有时候又不想,所以在双击事件里如此行写, 然后在需要双击执行我们方法之前+=,之后-=
if (CatShot !=null)
{
CatShot();
}
}
}
class Mouse
{
private string name;
public Mouse(string name)
{
this.name = name;
}
// 执行内容体
public void Run()
{
Console.WriteLine("老猫来了,{0}快跑",name);
}
}
}
关于事件的自定义参数,如下
private void tabControlMain_SelectedPageChanged(object sender, DevExpress.XtraTab.TabPageChangedEventArgs e)
这些参数,我们可以用自定义类, 并如下调用
if (PersonSelectChanged != null && _PickingInvokeMethod) { PersonSelectChanged(null, new PersonSelectEventArgs() { Persons = GetSelectedPerson }); };
转载：https://blog.csdn.net/spw55381155/article/details/116586665