委托、泛型与事件

1.请简述.NET Framework是什么？
Framework和.NET Core有什么区别？
3.请解释一下什么是装箱和拆箱？
4.什么是垃圾回收？请简述.NET Framework中的垃圾回收机制。

5.请解释一下什么是委托？在.NET Framework中如何使用委托？
6.什么是事件？在.NET Framework中如何使用事件？
7.请简述一下.NET Framework中的异常处理机制。

8.请解释一下什么是泛型？在.NET Framework中如何使用泛型？
9.请解释一下什么是LINQ？在.NET Framework中如何使用LINQ？
10.请解释一下什么是反射？在.NET Framework中如何使用反射？
以上问题只是.NET Framework面试中的一部分，具体的面试题还会根据面试官的要求和应聘的职位有所不同。

委托和事件的区别委托的本质，是⼀个类，⽽事件，是⼀个委托类型的私有变量加上两个公有⽅法（事件的+=和-=），这是本质区别。

打个⽐⽅，string 也是⼀个类，⽽string s = "a"，这个s是string类型的⼀个变量（略有不恰当，为了⽅便直观理解）。

public delegate void myDel();相当于你创建了⼀个myDel的类，所以委托可以在任何地⽅创建，类需要实例化，所以委托需要实例化，要myDel m = ……;申明⼀个事件 public event myDel myEvent;事件myEvent是⼀个myDel类型的⼀个变量，因为是变量，所以事件只能在类⾥⾯申明，不需要实例化，有点类似与上⾯的那个m，当然不全是,他还有两e79fa5e98193e4b893e5b19e31333366306531个⽅法（+=，-=），调⽤⼀次+=⽅法，myEvent += MethodA;其实是把MethodA⽅法，封装成⼀个myDel类型的委托对象，然后把这个对象的引⽤赋值给这个myEvent变量。

如果多次调⽤+=，就是多个⽅法封装成了多个myDel委托对象，然后这些委托对象放在⼀个列表⾥⾯，然后myEvent就指向这个列表，触发的时候，就是调⽤这个列表⾥⾯的所有委托的Invoke⽅法。

转delegate是C#中的⼀种类型，它实际上是⼀个能够持有对某个⽅法的引⽤的类。

与其它的类不同，delegate类能够拥有⼀个签名（signature），并且它"只能持有与它的签名相匹配的⽅法的引⽤"。

它所实现的功能与C/C++中的函数指针⼗分相似。

它允许你传递⼀个类A的⽅法m给另⼀个类B的对象，使得类B的对象能够调⽤这个⽅法m。

但与函数指针相⽐，delegate有许多函数委托和事件在 .Net Framework中的应⽤⾮常⼴泛指针不具备的优点。

⾸先，函数指针只能指向静态函数，⽽delegate既可以引⽤静态函数，⼜可以引⽤⾮静态成员函数。

委托应⽤场景[摘]委托除了实现事件外，还能够实现很多⾮常有⽤的语⾔特性。

1、Lambda 表达式。

Lambda 表达式有两种存在⽅式，⼀是匿名委托，⽽是表达式树。

2、匿名⽅法。

不指定名称的委托成为匿名委托。

有时候⾮常有⽤，如在绑定事件处理程序或者创建线程时。

3、多线程同步以及跨线程操作。

4、泛型委托。

5、基于委托的逆变 (Contravariance) 和协变 (Covariance)。

跨线程访问实例不允许在winform中直接跨线程访问控件例如:public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { Thread thread = new Thread(ThreadFuntion); thread.IsBackground = true; thread.Start(); } private void ThreadFuntion() { while (true) { this.textBox1.Text = DateTime.Now.ToString(); Thread.Sleep(1000); } } }会看到系统抛出⼀个异常:Cross-thread operation not valid:Control 'textBox1' accessed from a thread other than the thread it was created on .这是因为.net 2.0以后加强了安全机制,不允许在winform中直接跨线程访问控件的属性.那么怎么解决这个问题呢, 就是使⽤delegate和invoke来从其他线程中控制控件信息例如:public partial class Form1 : Form { private delegate void FlushClient();//代理 public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { Thread thread = new Thread(CrossThreadFlush); thread.IsBackground = true; thread.Start(); } private void CrossThreadFlush() { while (true) { //将sleep和⽆限循环放在等待异步的外⾯ Thread.Sleep(1000); ThreadFunction(); } } private void ThreadFunction() { if (this.textBox1.InvokeRequired)//等待异步 { FlushClient fc = new FlushClient(ThreadFunction); this.Invoke(fc);//通过代理调⽤刷新⽅法 } else { this.textBox1.Text = DateTime.Now.ToString(); } } }。

C#基础知识学习之✨委托（delegate）与事件（event）之间的介绍委托(delegate) 与事件(event)前言在之前的文章里介绍了C#中的委托(delegate)(Action、Func、Predicate)的基本含义及用法那本篇文章在这里还要介绍一个跟委托有很大关系的小伙伴——C#中的事件(event)事件跟委托是有很大联系的，所以也就导致很容易分不清他们两个，以及什么时候用这两个上面有博客提到委托，想单独了解委托的可以去看一下，本篇文章主要说一下什么是事件以及事件与委托的区别委托和事件的定义委托在这里再说一遍委托跟事件的简单定义(没有搜到特别准确的，都是大概定义，理解万岁)委托：delegate 是一种可用于封装命名或匿名方法的引用类型。

委托类似于 C++ 中的函数指针；但是，委托是类型安全和可靠的。

委托是一种动态调用方法的类型，属于引用型。

委托是对方法的抽象和封装。

委托对象实质上代表了方法的引用（即内存地址）委托允许将方法作为参数进行传递。

委托可用于定义回调方法。

委托可以把多个方法链接在一起。

这样，在事件触发时可同时启动多个事件处理程序。

委托签名不需要与方法精确匹配。

事件事件：事件是特殊类型的多路广播委托，仅可从声明它们的类或结构（发行者类）中调用。

如果其他类或结构订阅了该事件，则当发行者类引发该事件时，会调用其事件处理程序方法。

事件表示C#中已定义的一个对象，即处理通知过程的对象通常，每个事件的发生都会产生发送方和接收方。

在.net框架中，事件是将事件发送者（触发事件的对象）与事件接受者（处理事件的方法）相关联的一种代理类，即事件机制是通过代理类来实现的。

当一个事件被触发时，由该事件的代理来通知（调用）处理该事件的相应方法委托和事件的区别简单说了一下两者的定义，眼神好的小伙伴这时候就会发现，事件的说明里有提到一句话：“事件也可以算一种特殊的委托”，这句话不是特别准确，但是也不妨可以这样理解。

C#委托（delegate）、泛型委托和Lambda表达式⽬录# 什么是委托1、从数据结构来讲，委托是和类⼀样是⼀种⽤户⾃定义类型。

2、委托是⽅法的抽象，它存储的就是⼀系列具有相同参数和返回类型的⽅法的地址。

调⽤委托的时候，委托包含的所有⽅法将被执⾏。

# 委托声明、实例化和调⽤1、声明委托是⼀种特殊的类，因此委托的声明与类的声明⽅法类似，在任何可以声明类的地⽅都可以声明委托。

委托声明⽤delegate关键字，同时委托要指明⽅法参数和返回值，写法与⽅法类似。

综合类的声明和⽅法的声明，委托声明写成如下形式：[访问修饰符] delegate 返回值类型委托名（形参列表）;public delegate void MyDel();//定义了⼀个委托MyDel,它可以注册返回void类型且没有参数的函数public delegate void MyDel1(string str);//定义了⼀个委托MyDel1,它可以注册返回void类型且有⼀个string作为参数的函数public delegate int MyDel2(int a,int b);//定义了⼀个委托MyDel2,它可以注册返回int类型且有两个int作为参数的函数2、委托的实例化与普通类的使⽤⽅法相同，声明了委托之后，我们必须给委托传递⼀个具体的⽅法，才能在运⾏时调⽤委托实例。

委托实例包含了被传递给它的⽅法的信息，在运⾏时，调⽤委托实例就相当于执⾏它当中的⽅法。

委托实例化格式如下：委托类名委托实例名 = new 委托类名(Target) ;其中，委托实例名是⾃定义的名称，Target是要传⼊的⽅法的名称。

注意，Target是⽅法的引⽤，不能带()。

带()的话是该⽅法的调⽤。

区分引⽤和调⽤。

委托的实例化还有⼀种简单的⽅法：委托类名委托实例名 = Target;在需要委托实例的地⽅直接传⼊Target引⽤即可，C#编译器会⾃动根据委托类型进⾏验证，这称为“委托推断”。

委托和事件的关系1.委托的定义: delegate 是⼀种可⽤于封装命名或匿名⽅法的引⽤类型。

委托类似于 C++ 中的函数指针；但是，委托是类型安全和可靠的(MSDN的定义)。

委托是引⽤类型。

委托还有⼀些泛型委托： Action<T>只能委托⽆返回值的⽅法，⽽且可以传⼊的参数个数在0-16之间。

Predicate<T>委托返回bool值的的⽅法，只能输⼊⼀个参数类型。

public class People{public event Predicate<int> Compare;public void Start(){if (pare(1))Console.WriteLine("开始");elseConsole.WriteLine("等待");}}//调⽤People p = new People();pare += (int preValue) => { if (preValue == 1)return true; else return false; };p.Start(); Func<TResult>绑定⼀个参数（范围0-16）但却返回 TResult 参数指定的类型值的⽅法 例如：Func<T，TResult> Func<T，T，TResult> Func<T，T，...，TResult>例如：2.事件的定义： 事件是⼀种特殊的委托，是委托的⼀种特殊应⽤。

委托是事件的基础，通过将委托与命名⽅法或者匿名⽅法关联，可以实例化委托，然后委托实例化相应的事件。

　事件的使⽤⽅式:事件能通过+=和-=两个⽅式注册或者注销对其处理的⽅法，使⽤+=与-=操作符的时候，系统会⾃动调⽤对应的add_XXX、remove_XXX 进⾏处理。

　事件处理⽅法的绑定:在绑定事件处理⽅法的时候，事件出现在+=、-= 操作符的左边，对应的委托对象出现在+=、-= 操作符的右边。

C练习题一、基础语法1. 声明一个整型变量并赋值为10。

2. 声明一个浮点型变量并赋值为3.14。

3. 声明一个字符串变量并赋值为"Hello, World!"。

4. 声明一个布尔变量并赋值为true。

5. 创建一个名为`MyClass`的类，并在其中声明一个名为`myField`的私有整型字段。

6. 在`MyClass`类中添加一个构造函数，接受一个整型参数并赋值给`myField`字段。

7. 在`MyClass`类中添加一个名为`PrintField`的方法，打印出`myField`字段的值。

二、控制结构8. 编写一个程序，使用`if`语句判断一个整数变量是否大于0。

9. 编写一个程序，使用`switch`语句根据整数变量的值输出对应的星期名称。

10. 编写一个程序，使用`for`循环打印1到10的数字。

11. 编写一个程序，使用`foreach`循环遍历一个整数数组并打印每个元素。

12. 编写一个程序，使用`while`循环计算1到10的阶乘。

三、函数和方法13. 编写一个名为`Add`的方法，接受两个整数参数并返回它们的和。

14. 编写一个名为`Multiply`的方法，接受两个整数参数并返回它们的乘积。

15. 编写一个名为`PrintNumbers`的方法，接受一个整数参数，打印从1到该参数的所有数字。

16. 编写一个名为`ReverseString`的方法，接受一个字符串参数并返回其反转后的字符串。

17. 编写一个名为`FindMax`的方法，接受一个整数数组参数并返回数组中的最大值。

四、面向对象18. 创建一个名为`Person`的类，包含姓名和年龄两个属性。

19. 在`Person`类中添加一个构造函数，接受姓名和年龄作为参数。

20. 在`Person`类中添加一个名为`PrintInfo`的方法，打印出该人的姓名和年龄。

21. 创建一个`Student`类，继承自`Person`类，并添加一个名为`Grade`的属性。

c#委托、泛型委托和匿名⽅法题外话：别指望看第⼀遍书就能记住和掌握什么——请看第⼆遍、第三遍。

本⼈⼥猿⼀枚，2年⼯作经验，喜欢钻研，喜欢创新，闲暇之余喜欢写写博客，深知⾃⾝能⼒薄弱，如表达错误、不当之处请园友们多多指出，互相交流。

最近在学习lambda表达式，lambda表达式与匿名⽅法有着密切联系，⽽匿名⽅法⼜离不开委托，索性我就围绕委托、泛型、匿名⽅法做个总结，以加深我的理解，总结的内容很基础，希望各位⼤神看后勿喷。

⾸先，引⽤MSDN上的原话解释这⼏个名词：委托：是⼀种引⽤⽅法的类型。

⼀旦为委托分配了⽅法，委托将与该⽅法具有完全相同的⾏为。

泛型：泛型是 2.0 版 C# 语⾔和公共语⾔运⾏库 (CLR) 中的⼀个新功能，使⽤泛型类型可以最⼤限度地重⽤代码、保护类型的安全以及提⾼性能。

匿名⽅法：在 2.0 之前的 C# 版本中，声明的唯⼀⽅法是使⽤。

C# 2.0 引⼊了匿名⽅法。

要将代码块传递为委托参数，创建匿名⽅法则是唯⼀的⽅法。

如果使⽤匿名⽅法，则不必创建单独的⽅法，因此减少了实例化委托所需的编码系统开销。

MSDN解释的挺透彻的了，我就不多嘴了，下⾯看看具体的实例。

委托有了委托，我们就可以把⽅法当成参数来传递，⽤委托对象调⽤它所指向的⽅法，委托与c++中的指针很相似，但是委托是类型安全的。

⾸先先看⼀个例⼦：⼩张委托⼩明去打热⽔：//定义⼀个委托public delegate void GetHotWaterEventHandler();static void Main(string[] args){//声明⼀个委托对象，并绑定⼀个⽅法GetHotWaterEventHandler Getwater = new GetHotWaterEventHandler(MyHotWater);Getwater();//使⽤委托调⽤⽅法Console.ReadKey();}//⼩明打热⽔⽅法private static void MyHotWater(){Console.WriteLine("Oh,NO!命苦的我⼜要去打热⽔了！");}上⾯就是⼀个简单的委托，该委托没有返回值，没有传⼊参数，实际使⽤时，委托的返回值和形参要与绑定的⽅法相同，否则会报错。

什么是委托？什么是事件？事件与委托的区别？什么是委托？委托是种：引⽤⽅法的对象。

此对象可以将指针指向引⽤的⽅法，也可以说对象(委托)将消息发给订阅者(⽅法)什么是事件？事件与委托的区别？事件是种：特殊的委托区别：事件是解决委托的两个缺陷1、不⼩⼼取消掉订阅者 (封装订阅)委托允许使⽤ +=和= 两种运算符，就会导致不⼩⼼取消掉订阅者，⽽事件不允许使⽤=2、包容类外也可以(发布)通知 (封装发布)事件确保只有包容类才能触发⼀个事件通知 [不允许类的外部执⾏事件通知] （事件只能在定义的类中调⽤(发布)）换⾔之，事件提供了必要的封装来防⽌任何外部类发布⼀个事件或者取消之前的订阅者。

这样，就完美的解决了普通委托存在的两个问题PS: 参考《C#本质论》事件就是要解决下列代码中：+=和= ，在外部类中发布委托的问题public class Cooler{public Cooler(int temperature){this.Temperature = temperature;}public int Temperature { get; set; }public void OnTemperaTureChanged(int tem){if (tem > Temperature){Console.WriteLine($"Cooler On");}else{Console.WriteLine($"Cooler Off");}}}public class Heater{public Heater(int temperature){this.Temperature = temperature;}public int Temperature { get; set; }public void OnTemperaTureChanged(int tem){if (tem < Temperature){Console.WriteLine($"Heater On");}else{Console.WriteLine($"Heater Off");}}}class委托or事件{//声明委托// public delegate string delegateHandle(object sender, HandleEventArgs args);////声明事件//public event delegateHandle eventHandle;////已发事件的⽅法//public void Method(HandleEventArgs args)//{// if (eventHandle != null)// {// eventHandle(this, args);// }//}public delegate void delegateHandle(int tem);private delegateHandle _OndelegateHandleChanged;public delegateHandle OndelegateHandleChanged{get { return _OndelegateHandleChanged; }set { _OndelegateHandleChanged = value; }}private int temperature;public int Temperature{get { return temperature; }set { temperature = value; if(OndelegateHandleChanged!=null)OndelegateHandleChanged(value); } }}static void Main(string[] args){委托or事件 or = new委托or事件();Cooler cooler = new Cooler(80);Heater heater = new Heater(60);//or.eventHandle += Or_eventHandle;//or.Method(handler);or.OndelegateHandleChanged += cooler.OnTemperaTureChanged;or.OndelegateHandleChanged += heater.OnTemperaTureChanged;or.OndelegateHandleChanged = heater.OnTemperaTureChanged;or.OndelegateHandleChanged(45);Console.ReadLine();}View Code。

c事件和委托的区别
委托和事件在Net Framework中的应用非常厂泛,然而,较好地理解委托和事件。

对很多接触C#时间不长的人来说并不容易。

它们就像是一道槛儿, 过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件就觉得心里别得慌，混身不自在。

1.委托的作用:
在不知道要执行的方法的具体代码时，可以先用一个委托变量来代替方法调用，注意委托的返回值，参数列表要确定,在实际调用之前,需要为委托赋值，否则为null。

2.事件的作用:
事件的作用和委托变量一样，只是功能上比委托变量有更多的限制，第一好比如只能通过+=或者=来绑定事件处理程序(方法)，第二只能在类内部去触发事件，感觉事件这个东西在winform程序里面用的比较多，平时封装的代码应该比较少用到这个。

3.委托和事件的关系:
从反编译Q的角度看IL代码的时候，事件的本质其实是由一个私有的委托变量和add_和remove_ 方法组成。

事件、索引、属性本质都是方法，在接口里面只能定义方法,所以事件、索引、属性他们可以被定义在接口里面。

C#委托⽤法详解⽬录1、什么是委托2、委托的定义3、委托的实例化3.1使⽤new关键字3.2使⽤匿名⽅法3.3使⽤Lambda表达式4、泛型委托5、C#内置泛型委托6、多播委托1、什么是委托从数据结构来讲，委托是和类⼀样是⼀种⽤户⾃定义类型。

委托是⽅法的抽象，它存储的就是⼀系列具有相同签名和返回回类型的⽅法的地址。

调⽤委托的时候，委托包含的所有⽅法将被执⾏。

2、委托的定义委托是类型，就好像类是类型⼀样。

与类⼀样，委托类型必须在被⽤来创建变量以及类型对象之前声明。

委托的声明原型是delegate <函数返回类型> <委托名> (<函数参数>)例⼦：public delegate void MyDelegate(int number);//定义了⼀个委托MyDelegate,它可以注册返回void类型且有⼀个int作为参数的函数3、委托的实例化3.1 使⽤new关键字委托实例化的原型是<委托类型> <实例化名>=new <委托类型>(<注册函数>)例⼦：MyDelegate _MyDelegate=new MyDelegate(CheckMod);//⽤函数CheckMod实例化上⾯的MyDelegate 委托为_MyDelegate3.2 使⽤匿名⽅法<委托类型> <实例化名>=delegate(<函数参数>){函数体};3.3 使⽤Lambda表达式class Program{//声明委托delegate int MyDelegate(int x, int y);static void Main(string[] args){//实例化委托//1、使⽤new关键字MyDelegate _myDelegate = new MyDelegate(GetSum);//2、使⽤匿名⽅法MyDelegate myDelegate = delegate(int x, int y){return x + y;};//3、使⽤Lambda表达式MyDelegate myDelegateLambda = (int x, int y) => { return x + y; };}static int GetSum(int x, int y){return x + y;}}4、泛型委托委托也⽀持泛型的使⽤泛型委托原型：delegate <T1> <委托名><T1,T2,T3...> (T1 t1,T2 t2,T3 t3...)例如：delegate T2 DelegateDemo<T1,T2>(T1 t);//定义有两个泛型（T1,T2）的委托，T2作为委托函数返回类型，T1作为委托函数参数类型static boo Check(int i){if(i%2==0){return true;}return false;}static void Main(string[] args){DelegateDemo<int, bool> _delegate =Check;//将泛型委托委托<T1,T2>实例化为<int,bool>，即表⽰有⼀个int类型参数且返回类型是bool的函数.Console.WriteLine(_delegate(9));//false}5、C#内置泛型委托C#共有3种内置泛型委托namespace DelegateDemo{class Program{//声明委托delegate int MyDelegate(int x, int y);static void Main(string[] args){//1、Action<T>只能委托必须是⽆返回值的⽅法Action<string> _action = new Action<string>(SayHello);_action("Hello World");//2、Fun<TResult>只是委托必须有返回值的⽅法Func<int, bool> _func = new Func<int, bool>(Check);_func(5);//3、Predicate:此委托返回⼀个bool值，该委托通常引⽤⼀个"判断条件函数"。

C#Action和Func区别前⾔： 1.委托是⼀个类，定义了⽅法的类型，使得可以将⽅法当作另⼀个⽅法的参数来进⾏传递。

把⼀个参数类型返回值相同⽅法名不同的⽅法当变量的⽅法叫委托。

为了实现程序的六⼤设计中的开闭原则：解耦，对修改关闭，对扩展开放。

逻辑分离。

直接调⽤函数和使⽤委托调⽤函数的区别就是是否⽅便对外扩展。

当我们窗体传值、线程启动时绑定⽅法、lambda表达式、异步等等情况下需要⽤到。

2.事件是⼀种特殊的委托，本质就是委托，事件是回调机制的⼀种应⽤。

当委托调⽤的函数达到某种条件时，可以通过回调通知调⽤者。

⼀：委托的申明 1. delegate ,⾄少0个参数，⾄多32个参数，可以⽆返回值，可以指定返回值类型 eg: public delegate int MethodDelegate(int x,int y); //两个参数，返回int类型 2. Action ,⾄少0个参数，⽆返回值的泛型委托 Action<int,string,bool> ，有传⼊int、string、bool类型的参数，⽆返回值的委托 eg: public void Test<Test>(Action<T> action,T p) { actoin(p); } 3. Func ,⾄少0个参数，⾄多16个参数，必须有返回值的泛型委托 Func<object,string,int> ，传⼊参数为object、string类型的参数，返回值为int的委托 eg: public int Test<T1, T2>(Func<T1, T2, int>func,T1 a,T2 b){ return func(a, b); } 4.Predicate ,有且只有⼀个参数，返回值只为 bool 类型 predicate<int> 表⽰传⼊为int类型的参数，返回bool类型的委托。

事件和委托的区别很多⼈说，事件即委托。

真的是这样吗？那么微软为何⼜要定义事件与委托两个概念呢？其实事件即委托，在我看来不如这样解释：事件是封装过的委托实例。

也就是说，事件是⾯向对象的产物，它是封装性⽐较典型的⽰例。

事件实际上是⼀个特殊的委托实例，不⽤事件也没有关系。

实际上事件只是削弱了委托的功能，event在编译器⾓度保护了你程序的安全，因为你只能使⽤+=、-=来注册事件了，⽽不能使⽤ = 为事件关联⽅法。

（在委托中还可以使⽤=来绑定⽅法，不过=是⼀种破坏性代码，不管之前是否已经绑定的有⽅法了，他都会将其清除）同⼀个⽅法你可以使⽤委托来调⽤，你也可以使⽤事件来调⽤。

那究竟有何不同？其实事件就是⼀个狭义的委托,也就是事件是⼀个⽤于事件驱动模型的专⽤委托.你可以在客户代码中直接调⽤委托来激发委托指向的函数,⽽事件不可以，事件的触发只能由服务代码⾃⼰触发。

也就是说在你的代码⾥委托你不但可以安排谁是它的调⽤函数,还可以直接调⽤它,⽽事件不能直接调⽤,只能通过某些操作触发。

除此之此，事件拥有委托的所有功能，包括多播特性。

即事件可以有多个事件处理函数,委托同样也可以是个多播委托.public class Heater{ private int temperature; public void BoilWater() { for (int i = 1; i <= 100; i++) { temperature = i; if (temperature > 95 && BoilEvent != null) { //执⾏委托，⽆需知道要执⾏哪些⽅法 BoilEvent(temperature); } } } public delegate void BoilHandle(int param); public event BoilHandle BoilEvent;//封装了委托}public class Alarm{ public void MakeAlert(int param) { Console.WriteLine("Alarm:⽔温已经超过{0}度.",param); }}public class Display{ public void ShowMsg(int param) { Console.WriteLine("Display:⽔已烧开,当前温度{0}度.", param); }}[TestClass]public class UnitTest1{ [TestMethod] public void TestMethod1() { Heater heater = new Heater(); Alarm alarm = new Alarm(); heater.BoilEvent += alarm.MakeAlert; heater.BoilEvent += new Display().ShowMsg; heater.BoilWater(); }}。

详解C#委托，事件与回调函数.Net编程中最经常用的元素，事件必然是其中之一。

无论在还是WINFrom开发中，窗体加载(Load),绘制(Paint),初始化(Init)等等。

“protected void Page_Load(object sender, EventArgs e)”这段代码相信没有人不熟悉的。

细心一点一定会发现，非常多的事件方法都是带了“object sender, EventArgs e”这两个参数。

这是不是和委托非常相似呢？一、委托（有些书中也称为委派）委托是什么呢？这个名字的意思已经赋予了我们想象的空间，你是编程的，你现在正在写一个网页，而JS是你不熟悉的，于是你委托你的一位同事来帮助你完成JS部分。

这就是委托，把你所不能做的事情交给其他人去做。

而怎么知道是哪个人去做呢？当然是要知道名字！而为了区别名字一样的不同人，因此，需要描述一个特征。

在C#中，委托的作用是这样描述的：委托就像一个函数的指针，在程序运行时可以使用它们来调用不同的函数。

这个其实和你委托同事完成 JS代码一样。

如果有两位同事可以做这件事情，他们只要做的结果能够满足你的需求（就像一个接口），尽管他们做的过程不一样，并且作出的效果也不一样，但是，能够达到你的要求就可以了。

1．简单的委托那委托需要承载哪些信息呢？首先，它存储了方法名，还有参数列表(方法签名),以及返回的类型。

比如：delegate string/*返回类型*/ ProcessDelegate(int i);这就是一个委托的定义。

蓝色部分是声明委托的关键字，红色部分是返回的类型，而黑色部分是委托的类型名，和一个类名差不多，而()里的就是参数部分。

它的意思是，你要使用这个委托来做事情的话，那么，做事情的方法必须满足以下条件：1、返回类型和委托的返回类型一致，这里是string类型；2、能且只能有一个参数，并且是int类型。

OK,满足以上两个条件，一切就可以工作了:)例如：1 using System;2 using System.Collections.Generic;3 using System.Text;45 namespace TestApp6 {7 /// <summary>8 /// 委托9 /// </summary>10 /// <param name="s1"></param>11 /// <param name="s2"></param>12 /// <returns></returns>13 public delegate string ProcessDelegate(string s1, string s2);1415 class Program16 {17 static void Main(string[] args)19 /* 调用方法 */20 ProcessDelegate pd = new ProcessDelegate(new Test().Process);21 Console.WriteLine(pd("Text1", "Text2"));22 }23 }2425 public class Test26 {27 /// <summary>28 /// 方法29 /// </summary>30 /// <param name="s1"></param>31 /// <param name="s2"></param>32 /// <returns></returns>33 public string Process(string s1,string s2)34 {35 return s1 + s2;36 }37 }38 }输出的结果是:Text1Tex22、泛型委托泛型的委托，就是然参数的类型不确定,例如代码改写为：using System;using System.Collections.Generic;using System.Text;namespace TestApp{/// <summary>/// 委托/// </summary>/// <param name="s1"></param>/// <param name="s2"></param>/// <returns></returns>public delegate string ProcessDelegate<T,S>(T s1, S s2);class Program{static void Main(string[] args){/* 调用方法 */ProcessDelegate<string,int> pd = new ProcessDelegate<string,int>(new Test().Process); Console.WriteLine(pd("Text1", 100));}public class Test{/// <summary>/// 方法/// </summary>/// <param name="s1"></param>/// <param name="s2"></param>/// <returns></returns>public string Process(string s1,int s2){return s1 + s2;}}}输出的结果就是：Text1100泛型的详细内容不属于本文的介绍范围，这里不加多说了。

.net面试常见问题1. 什么是.NET？它的优点是什么？.NET是微软公司开发的一个软件开发框架，它提供了很多组件和库，可以用多种语言编写代码，并且可以跨平台。

.NET的优点包括：可扩展性、易维护性、高可靠性、强类型支持、安全性、良好的性能等等。

2. 请解释一下.NET Framework和.NET Core的区别？.NET Framework是微软公司开发的基于Windows操作系统的.NET平台，它有很多集成的类库和工具。

而.NET Core是.NET Framework的一个跨平台版本，可以在Windows、Linux和MacOS操作系统上运行，并且它支持.NET Standard 库，这样可以更容易地编写跨平台的应用程序。

3. 请解释一下.NET中的CLR？CLR是运行.NET应用程序的虚拟机，它可以将IL代码编译成机器代码，并且负责内存管理、垃圾回收、安全等方面的任务。

4. 请解释一下.NET中的BCL？BCL（Base Class Library）是.NET Framework中常用的类库，它包含在System命名空间中的一组类，包括集合、IO、安全、反射、文本处理等方面的类，它们可以通过.NET Framework内置的工具进行使用和管理。

5. 请解释一下.NET中的GAC？GAC（Global Assembly Cache）是.NET Framework中用于管理全局程序集的地方，它可以提供程序集共享、版本控制、安全保护等方面的支持。

6. 什么是反射？在.NET 中如何使用反射？反射是一种动态获取类型信息、调用方法、创建对象等功能的机制。

在.NET中，可以使用System.Reflection命名空间下的API进行反射。

比如，利用反射可以获取一个类型的属性和方法列表，动态创建对象，调用方法等。

7. 什么是LINQ？它的优点和缺点是什么？LINQ（Language Integrated Query）是一种集成在.NET语言（如C#和 ）中的查询技术，它可以通过一种类SQL 的语法，直接在程序中对数据进行查询、过滤、排序、分组等操作，同时支持不同数据源的查询（如数据库、XML、集合等）。

C#中委托和事件的区别⼤致来说，委托是⼀个类，该类内部维护着⼀个字段，指向⼀个⽅法。

事件可以被看作⼀个委托类型的变量，通过事件注册、取消多个委托或⽅法。

本篇分别通过委托和事件执⾏多个⽅法，从中体会两者的区别。

□通过委托执⾏⽅法class Program{static void Main(string[] args){Example example = new Example();example.Go();Console.ReadKey();}}public class Example{public delegate void DoSth(string str);internal void Go(){//声明⼀个委托变量，并把已知⽅法作为其构造函数的参数DoSth d = new DoSth(Print);string str = "Hello,World";//通过委托的静态⽅法Invoke触发委托d.Invoke(str);}void Print(string str){Console.WriteLine(str);}}以上，○在CLR运⾏时，委托DoSth实际上就⼀个类，该类有⼀个参数类型为⽅法的构造函数，并且提供了⼀个Invoke实例⽅法，⽤来触发委托的执⾏。

○委托DoSth定义了⽅法的参数和返回类型○通过委托DoSth的构造函数，可以把符合定义的⽅法赋值给委托○调⽤委托的实例⽅法Invoke执⾏了⽅法但，实际上让委托执⾏⽅法还有另外⼀种⽅式，那就是：委托变量(参数列表)public class Example{public delegate void DoSth(object sender, EventArgs e);internal void Go(){//声明⼀个委托变量，并把已知⽅法作为其构造函数的参数DoSth d = new DoSth(Print);object sender = 10;EventArgs e = new EventArgs();d(sender, e);}void Print(object sender, EventArgs e){Console.WriteLine(sender);}}以上，○委托DoSth的参数列表和⽅法Print的参数列表还是保持⼀致○委托DoSth中的参数object sender通常⽤来表⽰动作的发起者，EventArgs e⽤来表⽰动作所带的参数。

系统核心引用感叹号系统核心引用是指系统中使用的重要组件或者类库，它们可以提供一些基本的功能，比如字符串操作、日期处理等。

在程序开发的过程中，经常会用到这些引用，以便简化代码、提高效率。

在.NET评台中，System.Core是一个重要的核心引用，它提供了许多常用的功能，包括LINQ查询、Lambda表达式、并行处理等。

在实际项目中，我们可能会频繁地使用到System.Core，因此了解它的具体用法以及内部实现是非常重要的。

在下面的文章中，我们将从以下几个方面来介绍System.Core的用法和内部实现：1. 简介System.Core- System.Core的作用- System.Core的命名空间和类库2. System.Core的常用功能- LINQ查询- Lambda表达式- 并行处理3. System.Core的内部实现- 泛型集合类- 委托和事件- 并行库的实现原理通过这篇文章，希望读者能够更加深入地了解System.Core的用法和内部实现，并能够在实际项目开发中灵活运用它，提高开发效率，为项目的顺利进行做出更大的贡献。

1. 简介System.Core在.NET评台中，System.Core是一个重要的核心引用，在命名空间System上定义了一些重要的类和接口。

它提供了许多常用的功能，比如LINQ查询、Lambda表达式、并行处理等。

下面我们来具体介绍一下System.Core的作用和命名空间以及类库。

1.1 System.Core的作用System.Core提供了许多常用的功能，可以简化代码、提高效率。

它可以帮助开发人员快速实现一些复杂的功能，比如数据查询、集合操作等。

它也提供了一些高级的功能，比如并行处理，可以帮助开发人员更好地利用多核处理器，提高程序的运行效率。

1.2 System.Core的命名空间和类库在System.Core中，定义了一些重要的命名空间和类库，包括System.Linq、System.Collections.Generic等。