C#中 委托与事件

最新推荐文章于 2024-07-04 00:00:20 发布
最新推荐文章于 2024-07-04 00:00:20 发布
阅读量258 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40271467/article/details/78494466
版权

c# 中 委托与事件

1.委托

是函数指针的升级版 也是类的一种

我们以两个比较常用的简单委托为示例：

Action（无返回值） 委托 与 Func（有返回值） 委托

namespace weituo_Demo{

class Program
{
    static void Main(string[] args)
    {
        Calculate calculate = new Calculate();
        Action action = new Action(calculate.Report);
        calculate.Report();
        action.Invoke();
        action();
        Func<int, int, int> func1 = new Func<int, int, int>(calculate.Add);
        Func<int, int, int> func2 = new Func<int, int, int>(calculate.Sub);
        int x = 100;
        int y = 200;
        int z = 0;
        z = func1.Invoke(x, y);
        Console.WriteLine(z);
        z = func2.Invoke(x, y);
        Console.WriteLine(z);
    }
}
​
class Calculate
{
    public void Report()
    {
        Console.WriteLine("I have 3 methods"); 
    
    }
    public int Add(int a ,int b)
    {
        int result =a+b;
        return result;
    }
    public int Sub(int a  ,int b)
    {
        int result = a - b;
        return result;
    }
​
}

}

自定义委托类型:

namespace weituo_demo2{


public delegate double Calc(double x, double y);

class Program
{
    static void Main(string[] args)
    {
        Calculator calcluator = new Calculator();
        Calc calc1 = new Calc(calcluator.Add);
        Calc calc2 = new Calc(calcluator.Sub);
        Calc calc3 = new Calc(calcluator.Mul);
        Calc calc4 = new Calc(calcluator.Div);
        double a = 100;
        double b = 200;
        double c = 0;
​
        c = calc1.Invoke(a, b);
        Console.WriteLine(c);
        c = calc2.Invoke(a, b);
        Console.WriteLine(c);
        c = calc3.Invoke(a, b);
        Console.WriteLine(c);
        c = calc4.Invoke(a, b);
        Console.WriteLine(c);
    }
}
​
class Calculator
{
    public double Add(double x,double y)
    {
        return x + y;
    }
    public double Sub(double x, double y)
    {
        return x - y;
    }
    public double Mul(double x,double y)
    {
        return x * y;
    }
    public double Div(double x,double y)
    {
        return x / y;
    }
​
}

}

在自定义委托时要与所封装的方法保证类型兼容 {

​ 返回值的数据类型一致

​ 参数列表在个数和数据类型上一致

​ }

委托的一般使用 ：

实例： 把方法当作参数传给另一个方法

​ a. 模板方法: “借用 ”指定的外部方法来产生结果

​ 相当于“填空题 ”

​ 常位于代码中部

​ 委托有返回值

​ b. 回掉方法： 调用指定的外部方法

​ 相当于“流水线”

​ 常位于代码末尾

​ 委托无返回值

a.模板方法：

​ namespace weituo_Demo3{


class Program
{
    static void Main(string[] args)
    {
        ProductFactory productFactory = new ProductFactory();
        WrapFactory wrapFactory = new WrapFactory();
        Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
        Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);
​
        Box box1 = wrapFactory.WrapProduct(func1);
        Box box2 = wrapFactory.WrapProduct(func2);
        Console.WriteLine(box1.Product.Name);
        Console.WriteLine(box2.Product.Name); 
    }
}
class Product
{
    public string Name { get; set; }
}   
​
class Box
{
   public Product Product { get; set; }
}
class WrapFactory
{
     public Box WrapProduct(Func<Product> getProduct)   // 模板方法
    {
        Box box = new Box();
 
        box.Product = getProduct.Invoke(); 
        return box;
    }
}
​
class ProductFactory
{
    public Product MakePizza()
    {
        Product product = new Product(); 
        product.Name = "Pizza";
        return product;
    }
​
    public  Product MakeToyCar()
    {
        Product product = new Product();
        product.Name = "Toy Car";
        return product; 
​
    }
   
}

}

b.回调方法

namespace weituo_Demo3{


class Program
{
    static void Main(string[] args)
    {
        ProductFactory productFactory = new ProductFactory();
        WrapFactory wrapFactory = new WrapFactory();
        Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
        Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);
​
        Logger logger = new Logger();
        Action<Product> log = new Action<Product>(logger.Log); 
​
        Box box1 = wrapFactory.WrapProduct(func1,log);
        Box box2 = wrapFactory.WrapProduct(func2,log);
        Console.WriteLine(box1.Product.Name);
        Console.WriteLine(box2.Product.Name); 
    }
}
class Logger
{
    public void Log(Product product)
    {
        Console.WriteLine("Product'{0}' created at{1}. Price is{2}.",product.Name,DateTime.UtcNow,product.Price);
​
    }
}
​
class Product
{
    public string Name { get; set; }
    public double Price { get; set; }
}   
​
class Box
{
   public Product Product { get; set; }
}
class WrapFactory
{
     public Box WrapProduct(Func<Product> getProduct,Action<Product> logCallback)   // 模板方法
    {
        Box box = new Box();
 
        box.Product = getProduct.Invoke(); 
        if(box.Product.Price>= 50)
        {
            logCallback(box.Product);
        }
        return box;
    }
}
​
class ProductFactory
{
    public Product MakePizza()
    {
        Product product = new Product(); 
        product.Name = "Pizza";
        product.Price = 12;
        return product;
    }
​
    public  Product MakeToyCar()
    {
        Product product = new Product();
        product.Name = "Toy Car";
        product.Price = 100;
        return product; 
​
    }
   
}

}

​ 无论是模板方法还是回调方法都是利用委托类型的参数封装一个外部的方法，然后把方法传进方法的内部，再进行间接调用；这就是对委托的常规用法。

委托的高级使用：

多播委托

​ action1 += action2;

​ action1 += action3;

​ action1.Invoke();

隐式异步调用

​ action1.BeginInvoke(null,null);

​ action2.BeginInvoke(null,null);

​ action3.BeginInvoke(null,null);

显示异步调用

​ Task task1 = new Task(new Action(stu.DoHomework));

​ task1.Start();

2.事件

a.事件的拥有者（event source,对象）

b.事件成员(event ,对象)

c.事件的响应者(event subscriber, 对象)

d.事件处理器(event handler,成员)---本质上是一个回调方法

e.事件订阅-----把事件处理器与事件关联在一起，本质上市一种以委托类型为基础的“约定”

注意： 事件处理器是方法成员

​ 挂接事件处理器的时候，可以使用委托实例，也可以直接使用方法名，这是个语法糖

​ 事件处理器对事件的订阅不是随意的，匹配与否由声明事件时所使用的委托类型来检查

​ 事件可以同步调用也可以异步调用

eg:

1.namespace Event_Demo{


class Program
{
    static void Main(string[] args)
    {
        Timer timer = new Timer();
        timer.Interval = 1000;
        Boy boy = new Boy();
        timer.Elapsed += boy.Action;
        timer.Start();
          Console.ReadLine();
        
    }
}
class Boy
{
    internal void Action(object sender, ElapsedEventArgs e)
    {
        Console.WriteLine("Jump");
    }
}

}

2.

namespace Event_Demo{


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;
            this.form.Click += this.FormClicked;
        }
    }
​
    private void FormClicked(object sender, EventArgs e)
    {
        this.form.Text = DateTime.Now.ToString();
    }
}

}

3.

namespace Event_Demo{


class Program
{
    static void Main(string[] args)
    {
        MyForm form = new MyForm();      //事件拥有者，事件响应者
        form.Click += form.FormClicked;
        form.ShowDialog();
    }
}
class MyForm : Form
{
    internal void FormClicked(object sender, EventArgs e)
    {
        this.Text = DateTime.Now.ToString();
    }
}

}

4.namespace Event_Demo{


class Program
{
    static void Main(string[] args)
    {
        MyForm form = new MyForm();    //事件响应者
        form.ShowDialog();
    }
}
class MyForm : Form
{
    private TextBox textbox;
    private Button button;     //事件拥有者
    public MyForm()
    {
        this.textbox = new TextBox();
        this.button = new Button();
        this.Controls.Add(textbox);
        this.Controls.Add(button);
        this.button.Click += this.ButtonClicked;
    }
​
    private void ButtonClicked(object sender, EventArgs e)
    {
        this.textbox.Text = "Hello World!";
    }
}

}

事件是基于委托的：

1.事件需要委托类型作为约束，这个约束既规定了事件能够发送什么消息给事件的响应者，也规定了事件的响应者能收到什么消息。这就决定了事件响应者的事件处理器必须能跟这个事件约束匹配上 它才能够订阅这个事件

2.当事件的相应者向事件的拥有者提供了能够匹配这个事件的事件处理器之后，总的找个地方把这个事件保存或者记录下来，能够记录或者引用方法的任务 只有委托才能做到 所以又要用到委托；

总结一下 ： 事件无论从表层约束来讲或者从底层实现来讲都是依赖委托类型 。

​ 委托是事件的底层基础 ，事件是委托的上层建筑。

（声明委托时 ，如果委托是为了某一个事件准本的 委托名必须以EventHandler 作为后缀 用来传递事件消息的类 以 EventArgs 做后缀）

事件的参数 sender objiect 类型 实际上就是事件的拥有这 source

​ EventArgs派生类 参数名为e 也就是事件参数

​ 触发事件的访问级别一般为protected 如果为 public 就会变成"借刀杀人"

事件完整声明

namespace Event_Demo{


class Program
{
    static void Main(string[] args)
    {
        Customer customer = new Customer();
        Waiter waiter = new Waiter();
        customer.order += waiter.Action;
        customer.Action();
        customer.PayTheBill();

    }
}
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;
    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}.",this.Bill);
    }
    public  void WalkIn()
    {
        Console.WriteLine("Walk into the restaurant");
    }
    public void SitDown()
    {
        Console.WriteLine("Sit Down");
    }
    public void Think()
    {
        for(int i = 0; i<5; i++)
        {
            Console.WriteLine("Let me think...");
            Thread.Sleep(1000);
        }
        if(this.orderEventHandler != null)
        {
            OrderEventArgs e = new OrderEventArgs();
            e.DishName = "Kongpao Chicken";
            e.Size = "Large";
            this.orderEventHandler.Invoke(this, e);
        }
    }
    public void Action()
    {
        Console.ReadLine();
        this.WalkIn();
        this.SitDown();
        this.Think();
    }
   
}
   
public class Waiter
{
   public void Action(Customer customer, OrderEventArgs e)
    {
        Console.WriteLine("I will serve you the dish-{0}.",e.DishName);
        double price = 10;
        switch(e.Size){
            case "Small":
            price = price * 0.5;
                break;
            case "Large":
                price = price * 1.5;
                break;
            default:
                break; 
        }
        customer.Bill += price;
    }
}

}

事件简化声明：（字段式声明）

namespace Event_Demo{


class Program
{
    static void Main(string[] args)
    {
        Customer customer = new Customer();
        Waiter waiter = new Waiter();
        customer.Order += waiter.Action;
        customer.Action();
        customer.PayTheBill();

    }
}
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


{
    public event OrderEventHandler Order;
​
    public double Bill { get; set; }
    public void PayTheBill()
    {
        Console.WriteLine(" I will pay ${0}.",this.Bill);
    }
    public  void WalkIn()
    {
        Console.WriteLine("Walk into the restaurant");
    }
    public void SitDown()
    {
        Console.WriteLine("Sit Down");
    }
    public void Think()
    {
        for(int i = 0; i<5; i++)
        {
            Console.WriteLine("Let me think...");
            Thread.Sleep(1000);
        }
        if(this.Order != null)
        {
            OrderEventArgs e = new OrderEventArgs();
            e.DishName = "Kongpao Chicken";
            e.Size = "Large";
            this.Order.Invoke(this, e);
        }
    }
    public void Action()
    {
        Console.ReadLine();
        this.WalkIn();
        this.SitDown();
        this.Think();
    }
   
}
   
public class Waiter
{
   public void Action(Customer customer, OrderEventArgs e)
    {
        Console.WriteLine("I will serve you the dish-{0}.",e.DishName);
        double price = 10;
        switch(e.Size){
            case "Small":
            price = price * 0.5;
                break;
            case "Large":
                price = price * 1.5;
                break;
            default:
                break; 
        }
        customer.Bill += price;
    }
}

}

所以事件的本质是委托字段的一个包装器

这个包装器对委托字段的访问起限制作用，相当于一个“蒙板”

封装的一个重要功能就是隐藏

事件对外界隐藏了委托实例的大部分功能，仅暴露 "添加/移除事件处理器的功能"

​

我摇了摇头
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 委托
LILI_JU88的博客
06-20 1258
委托的概念委托从字面上理解就是一种代理
C#中委托与事件的区别
11-13
委托 和 事件在 .Net Framework中的应用非常广泛，然而，较好地理解委托和事件。对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件...
C#委托
03-14 7409
Delegate，委托（或代理）是这样一种数据类型：它的变量可以引用到某一个符合要求的方法上，通过委托可以间接地调用该方法。C#的委托类似于C语言的函数指针，区别在于C#的委托是面向对象的。我们可以这样认为：在纯粹的面向对象语言C#中，方法也是一种特殊对象，对象的行为就是方法的行为，对象的属性是方法的返回值和参数列表。既然可以将方法认定为对象，那该对象也可以抽象出类来。这个类，就是Dele
全面解析：C# 委托的实质性应用与优势
最新发布
weixin_68436326的博客
07-04 17
前言有人问C#的委托（Delegate）有什么实质性用途?委托在C#其实是无处不在，那么它具体用在那里呢？。本文将从委托（Delegate）定义和演变讲起，让大家一目了然。C#的委托（Delegate）是强类型的函数指针，用于引用方法并允许将方法作为参数传递。随着C#的演变，委托的功能和用途变得越来越强大和灵活。本文将从C#委托的演变谈起，详细介绍其实质性用途，并通过代码实例加以证明。委托的演变C...
C#委托之个人理解
weixin_33734785的博客
03-31 109
什么是委托 　　首先要知道什么是委托，用最通俗易懂的话来讲，你就可以把委托看成是用来执行方法（函数）的一个东西。 如何使用委托 　　在使用委托的时候，你可以像对待一个类一样对待它。即先声明，再实例化。只是有点不同，类在实例化之后叫对象或实例，但委托在实例化后仍叫委托。 声明，如： 1    namespace Vczx.ProCSharp.Exc 2    { 3        de...
C#中的委托和事件(完整版)
06-14
详细讲述了C#中委托和事件的语法及其使用方法，用程序例子深入浅出的讲述了不同的使用方法和这些使用方法的优劣。
c#中的委托与事件
10-30
声明委托相当与声明一个新的类，所以可以在声明类的地方声明委托，可在类外声明，也可以在 * 类中声明 * 3.可以在委托的声明前加上任意的修饰符，public private * 4.定义委托和与之对应的方法必须具有相同的方法...
C#中的委托和事件（1）
01-27
委托和事件在.NetFramework中的应用非常广泛，然而，较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件就觉得...
C# 事件委托简单封装示例
11-02
在C#编程中，事件和委托是核心特性之一，它们为构建可扩展和灵活的代码提供了基础。事件委托的封装是提高代码复用性和模块化的重要手段。本示例将探讨如何在C#中实现事件委托的简单封装，并提供一个实际的应用场景。...
深化理解：C#中委托与事件的实战细节与误区
在C#中，委托和事件是面向对象编程的重要组成部分，它们允许组件之间通过事件机制进行通信，而不必暴露底层实现细节。本文深入探讨了以下几个关键知识点： 1. **事件与委托的区别**： - 委托是一种引用类型，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值