(28)C#委托,匿名函数,lambda表达式,事件

一、委托

委托是一种用于封装命名和匿名方法的引用类型。

把方法当参数,传给另一个方法(这么说好理解,但实际上方法不能当参数,传入的是委托类型),委托是一种引用类型,委托里包含很多方法的引用

创建的方法和声明的委托返回值类型相同,参数个数相同,参数类型相同时。 这个方法就满足属于这个委托(创建的方法是 public 或者是static 都没影响,只要前三项满足即可)

用普通方式创建一个委托

//声明委托(声明委托的位置也可以在class内部)
public delegate string del(double a, double b);
class Program
{
//定义一个求和方法
public string sumResult(double a, double b)
{
double sum = a + b;
string str1 = Convert.ToString(sum);
string str2 = "结果等于" + str1;
return str2;
}
//定义一个乘积方法
public string multiplyResult(double a, double b)
{
double sum = a * b;
string str1 = Convert.ToString(sum);
string str2 = "结果等于" + str1;
return str2;
}
static void Main(string[] args)
{
Program p = new Program();
       //加载一个相加方法
del sr = new del(p.sumResult); 
//可以简便方式加载一个方法
del mr = p.multiplyResult;
//调用委托对象传入参数,用string类型接收结果
string str1 = sr(, );
string str2 = mr(, );
Console.WriteLine(str1);
Console.WriteLine(str2);
Console.ReadKey();
}
}

引用静态方法的方式

//声明委托
public delegate string del(double a, double b);
//定义一个静态方法
public static string sumResult(double a, double b)
{
double sum = a + b;
string str1 = Convert.ToString(sum);
string str2 = "结果等于" + str1;
return str2;
}
static void Main(string[] args)
{
//用普通方式创建一个委托对象
del sr = sumResult; //用string类型接收结果
string str = sr(2.5, 3.5);
Console.WriteLine(str);
Console.ReadKey();
}

把多个方法存到一个数组,利用循环来调用不同方法

   //定义个委托,传入一个double参数,返回一个double。
delegate int delInt(int a);
class Program
{
static void Main(string[] args)
{
//定义并初始化一个数组。数组的类型为委托类型 --没想到还以用委托当类型
delInt[] delArray = { sumMethod.addTwo, sumMethod.XTwo};
for (int i = ; i < delArray.Length; i++)
{
Console.WriteLine("循环{0}",i);
display(delArray[i], );
display(delArray[i], ); }
Console.ReadKey();
}
//显示的方法
static void display(delInt del,int a)
{
int result = del(a);
Console.WriteLine("传入{0},计算结果为{1}", a, result);
}
}
//计算类
class sumMethod
{
//加2
public static int addTwo(int a)
{
return a + ;
}
//乘2
public static int XTwo(int a)
{
return a * ;
}
}

结果

(28)C#委托,匿名函数,lambda表达式,事件

到此为止以上的例子不能说明委托的意义,这些例子都能在不适用委托的情况下编写。

代表委托用法的例子

...

...

...

二、委托的多播

包含多个方法的委托叫做多播。

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

调用多播可以按顺序连续调用多个方法,委托的返回类型必须是void,否则只能得到委托调用最后一个方法的结果。

      delegate void del(int sum);//声明一个委托
class MyClass
{
public void shuchuB(int x)
{
Console.WriteLine(10 * x);
Console.ReadLine();
}
}
class Program
{
static void shuchuA(int x)
{
Console.WriteLine(20 * x);
Console.ReadLine();
}
static void Main(string[] args)
{
MyClass mc = new MyClass();
del a = shuchuA; //创建一个委托实例,持有一个静态方法
del b = mc.shuchuB; //持有一个实例方法
del c = a + b; //持有以上两个方法
c(5);
}
}

(28)C#委托,匿名函数,lambda表达式,事件

如果

del c = b+a+b;  

(28)C#委托,匿名函数,lambda表达式,事件

还有自加自的方式,如果一个del里有两个相同的方法,他会优先删除后进的。(后进先出)

 del b += a;
del b -= a;

多播委托可能遇到的问题

如果委托调用的其中一个方法抛出异常,整个迭代就会停止

        static void Main(string[] args)
{
//当一个委托没有参数也没有返回值时,就可以直接使用Action委托,无需声明
Action action = one;
action += two;
try
{
action();
}
catch (Exception)
{
Console.WriteLine("exception");
}
Console.ReadKey();
}
static void one()
{
Console.WriteLine("one");
throw new Exception("Error");
}
static void two()
{
Console.WriteLine("two");
}

(28)C#委托,匿名函数,lambda表达式,事件

为避免此问题,需要迭代方法列表

        static void Main(string[] args)
{
//当一个委托没有参数也没有返回值时,就可以直接使用Action委托,无需声明
Action action = one;
action += two;
//委托的GetInvocationList方法会按照加入顺序返回一个委托数组
Delegate[] dels = action.GetInvocationList();
foreach (Action act in dels)
{
try
{
act();
}
catch (Exception)
{
Console.WriteLine("exception");
}
}
Console.ReadKey();
}

三、泛型委托

1

(28)C#委托,匿名函数,lambda表达式,事件

2.

Action 简化了delegate的写法

Action返回类型必须是void,可以1-16任意参数类型<参数类型1,参数类型2,..>

(28)C#委托,匿名函数,lambda表达式,事件

也可以传不同参数类型

(28)C#委托,匿名函数,lambda表达式,事件

用var快速定义

(28)C#委托,匿名函数,lambda表达式,事件

3.有返回类型用Func

最后一个参数类型为返回类型

(28)C#委托,匿名函数,lambda表达式,事件

三、匿名函数

匿名方法有两种:匿名方法、Lambda表达式

在 2.0 之前的 C# 版本中,声明委托的唯一方法是使用命名方法。

C# 2.0 引入了匿名方法,而在 C# 3.0 及更高版本中,Lambda 表达式取代了匿名方法,作为编写内联代码的首选方式.

1.匿名方法

匿名方法比普通的委托写起来简练易读,在只一次调用方法时使用起来比较方便

语法:在创建委托实例的同时紧接着用花括号写入方法

public delegate string del(参数1,参数2,...);
A a =new A(参数1,参数2,...)
{
  .....
  .....
  return string类型;
};

注意几点:

(1)A 是一个委托

(2)创建委托实例时参数的个数和类型都必须与声明委托时一致

(3)花括号里的返回类型必须要与声明的返回类型一致

(4)末尾别忘加 ;

用匿名方式创建一个委托对象

class Program
{
//也可以外部声明
public delegate string del(double a, double b);
static void Main(string[] args)
{
Program p =new Program();
//用匿名方式创建一个委托对象
del sr = delegate(double a, double b)
{
double sum = a + b;
string str1 = Convert.ToString(sum);
string str2 = "结果等于" + str1;
return str2;
};
//用string类型接收结果
string str = sr(2.5, 3.5);
Console.WriteLine(str);
Console.ReadKey();
}
}

2、用lambda方法实现

通过使用 lambda 表达式,可以写入可作为参数传递或作为函数调用值返回的本地函数。 Lambda 表达式对于编写 LINQ 查询表达式特别有用。

调用时声明的方法,用一次就没。不用再单独声明个方法

格式:

若要创建 lambda 表达式,需要在 Lambda 运算符 =>左侧指定输入参数(如果有),然后在另一侧输入表达式或语句块。

例如,lambda 表达式 x => x * x 指定名为 x 的参数并返回 x 的平方值

单行lambda 表达式

    class Program
{ public delegate double del(double a, double b);
static void Main(string[] args)
{
Program p = new Program();
//用lambda表达式的方法
del sr = (a, b) => a + b;
//传入多个参数要加括号,如果是一个参数可以写成
//del sr = a => a * a; //开头注意声明的类型和下面这个接收的变量都是double
double d = sr(2.5, 3.5);
Console.WriteLine(d);
Console.ReadKey();
}
}

多行lambda 表达式

单行表达式省略了return、花括号和分号。用多行表达式时都要补充上。

            Program p = new Program();
del sr = (a, b) =>
{
return a + b;
};

泛型Lambda,可以重用

(28)C#委托,匿名函数,lambda表达式,事件

语法糖可省略 lambda参数类型

(28)C#委托,匿名函数,lambda表达式,事件

语法糖 不需要再创建实例,省略了 new Func<int,int,int>

这个是最常用的方式

(28)C#委托,匿名函数,lambda表达式,事件

进阶

(28)C#委托,匿名函数,lambda表达式,事件

泛型委托类型推断,省略了 <int>

(28)C#委托,匿名函数,lambda表达式,事件

 3.闭包

。。。。。

委托隐式异步调用

(28)C#委托,匿名函数,lambda表达式,事件

使用接口取代委托减少复杂性和安全性(java没有委托,就是用接口的方式)

四、事件

事件是一种类似于订阅/发布的机制。

把订阅当成一个方法,每次一订阅就会存一个方法进入委托中。等到发布的时候,一次性的发消息给哪些订阅。

例如:

日本丰田公司2017年生产了三款新车,(汉兰达2018,凯美瑞2018,雷凌2018)。

家住天津王兰庄附近的‘大刘’和‘小明’从网上看到消息后给王兰庄广汽丰田4S点打电话了解这三款车

4S点销售员告诉他们新车还没到货,让他们留下联系方式,等车到店了给你们发短信通知他们来店里看实车。

创建一个控制台程序

  再新建一个事件发布类:ReleaseEventArgs

再新建一个事件监听类:Consumer

  

    class ReleaseEventArgs : EventArgs
{
public ReleaseEventArgs(string car)
{
this.Car = car;
}
public string Car { get; set; } public class Shop
{
//
public event EventHandler<ReleaseEventArgs> NewCarClass;
public void NewCar(string car)
{
Console.WriteLine("{0}",car);
raise(car);
}
protected virtual void raise(string car)
{
EventHandler<ReleaseEventArgs> newCarClass = NewCarClass;
if (newCarClass != null)
{
newCarClass(this, new ReleaseEventArgs(car));
}
}
}
}
    class Consumer
{
private string name; public Consumer(string name)
{
this.name = name;
}
public void CarArriving(object sender, ReleaseEventArgs e)
{
Console.WriteLine("尊敬的{0},王兰庄4S点提示您:{1}到货了",name,e.Car);
}
}
    class Program
{
static void Main(string[] args)
{
var shop = new ReleaseEventArgs.Shop();
var daliu = new Consumer("大刘");
var xiaoming = new Consumer("小明");
shop.NewCarClass += daliu.CarArriving;
shop.NewCarClass += xiaoming.CarArriving;
shop.NewCar("汉兰达2018");
shop.NewCarClass -= daliu.CarArriving;
shop.NewCar("凯美瑞2018");
var zhoujie = new Consumer("周杰");
shop.NewCarClass += zhoujie.CarArriving;
shop.NewCar("雷凌2018"); Console.ReadKey();
}
}

https://www.cnblogs.com/gq0324/p/8177799.html

事件

using System;

namespace ConsoleApp4
{
class Program
{
static void Main(string[] args)
{
Business bus = new Business();
bus.Price = ;
bus.Changed += Test_Changed; bus.Price = ;
bus.Price = ;
Console.WriteLine("Hello World!"); void Test_Changed(object sender, ChangeEventArgs e)
{
if ((e.newPrice - e.oldPrice) > )
{
Console.WriteLine("大于10");
}
}
}
} //标准事件模式
//一个继承事件类的子类
public class ChangeEventArgs : EventArgs
{
public int oldPrice;
public int newPrice;
//ctor + tab
public ChangeEventArgs(int oldPrice, int newPrice)
{
this.oldPrice = oldPrice;
this.newPrice = newPrice;
}
} public class Business
{
int price; public event EventHandler<ChangeEventArgs> Changed; protected virtual void OnChange(ChangeEventArgs e)
{
Changed?.Invoke(this, e);
} public int Price
{
get { return price; }
set
{
if (price == value) return;
int oldPrice = price;
price = value;
OnChange(new ChangeEventArgs(oldPrice, price));
}
}
}
}

------------------------------------------------

为什么要用委托?

//定义
public delegate void del(int value);

实际上相当于:定义了一个类

    public class del:System.MulticastDelegate
{
//构造函数
public del(Object @object, IntPtr method);
//
public virtual void Invoke(Int32 value);
//回调方法的异步回调
public virtual IAsyncResult BeginInvoke(Int32 value, AsyncCallback callback, Object @object);
//回调方法的异步回调
public virtual void EndInvoke(IAsyncResult result);
}

异步调用完成时执行回调方法

异步启动委托, 参数与要执行的方法的参数相同,另加两个可选参数

第一个参数是一个 AsyncCallback 委托,此委托引用在异步调用完成时要调用的方法。

第二个参数是一个用户定义的对象,该对象将信息传递到回调方法。

BeginInvoke 将立即返回,而不会等待异步调用完成。

BeginInvoke 返回可用于监视异步调用的进度的 IAsyncResult。

委托对象.BeginInvoke();

EndInvoke 方法用于检索异步调用的结果,它可以在调用 BeginInvoke之后的任意时间调用

如果异步调用尚未完成,那么 EndInvoke 将阻止调用线程,直到完成异步调用

---------------------------------------

上一篇:懂一点Python系列——快速入门


下一篇:解决java.net.MalformedURLException: unknown protocol: c问题