c#语言新特性

最新推荐文章于 2023-06-14 10:49:35 发布

听音乐就好

最新推荐文章于 2023-06-14 10:49:35 发布

阅读量1k

点赞数

分类专栏： C# 文章标签： c# 语言 string lambda null class

C# 专栏收录该内容

79 篇文章 0 订阅

订阅专栏

c#2.0相对于c#1.1增加了很多特性，有一些特性，如新的迭代器，匿名方法等在c#2.0发布时，一般应用还看不到有特别的意义，到了c#3.0，LINQ技术的出现，是它们变得重要起来，c#语言新特性如下：

自动属性和属性访问器的保护级别
可空类型
泛型
代理
迭代器与yield关键字
隐式类型的局部变量
对象和集合初始化器
匿名类型
扩展方法
匿名方法和Lamda表达式

1.自动属性和属性访问器的保护级别

属性一般是来封装类型的字段，在.NET1.1的时候，首先定义私有类型的字段，然后通过属性来访问这个字段，到了2.0这个写法被简化了，例如：

//c#1.1中常见的属性应用
private int _id;

        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

//c#2.0中访问器带有保护级别的自动属性
public int ID { get;private set;}

自动属性只要定义访问器就可以上使用，编译器在编译时刻会添加一个随机命名的字段来存储数据。在2.0版本以后，属性访问器的保护级别也可单独定义，前提条件是访问器的保护级别不能大于属性的保护级别。

2.可空类型

c#语言以前只有引用类型的变量才可以赋值为null,2.0之后，出现可空类型。可空类型允许值类型变量为null,值类型变量为null的情况还是很多的，例如数据库中的字段就可以为null.

可空类型是泛型System.Nullable<T>结构体的实例，它在值类型正常范围的值的基础上，再加上一个null值。例如Nullable<Int32>,其赋值为-2147483648到2147483647之间的任意值和null值，Nullable<bool>值包括true、false或null.

可空类型的语法是Nullable<T>,也可以写成T？，这里的T必须是值类型。T？？使用两个问号，表示调用类型的默认值。

如下面的控制台应用程序所示：

using System; namespace DemoNullable { /// <summary> /// 定义一个结构体 /// </summary> public struct Test { string stest; public string Test1 { get { return stest; } set { stest = value; } } public Test(string s) { this.stest = s; } } /// <summary> /// 定义一个枚举 /// </summary> enum TestEnm { Test1, Test2 } class Program { static void Main(string[] args) { Test? stru = null; if (stru == null) { Console.WriteLine("结构体也可以为NULL"); stru = new Test("默认字符串"); //可空类型结构体初始化后，不能取消装箱来修改结构体 //只能把值传递出来 Test vv = stru.Value; vv.Test1 = "Test String"; Console.WriteLine(vv.Test1); //箱内的值 Console.WriteLine(stru.Value.Test1); } Console.WriteLine("***************************"); TestEnm? enu = null; if (enu == null) { Console.WriteLine("枚举类型也可以为NULL"); enu = TestEnm.Test1; Console.WriteLine(enu); } Console.WriteLine("***************************"); int? i = null; if (i == null) { Console.WriteLine("Int 类型也可以为NULL"); i = 100; Console.WriteLine(i); } Console.WriteLine("***************************"); bool? b = null; if (b == null) { Console.WriteLine("布尔类型也可以为NULL"); b = true; Console.WriteLine(b); } Console.WriteLine("***************************"); i = null; Console.WriteLine(string.Format("调用 i 的默认值：{0}",i??+0)); //Test erstru = null; //TestEnm erenu = null; //int eri = null; //bool erb = null; Console.ReadKey(); } } }

3.泛型

c#语言是强类型语言，定义变量和对象都必须声明类型，这一点不同与Javascript、PHP等脚本语言。

强类型语言的优点是明显的，例如，更容易写成内存安全的代码，执行速度更快等，但是缺点也是存在的，比如，函数或类的通用化问题。

在泛型出现以前，如果想让一个函数的参数或类的属性实用性更广，参数或属性的数据类型可以使用Object类型，Object类型是.NET所有类型的基类，编译通过是没有问题，但使用传入的数据时，必须进行类型强制转化。

在实际开发的过程中，经常使用到集合类。在倍于泛型集合以前，ArrayList是比较常用的集合类，因为ArrayList可以装入基于 Object类型的任何元素。这样做看似非常便利，其实效率很低，代价很明显的。

ArrayList添加的元素不论是应用类型还是值类型，都会被隐式的强制转换为Object类型。并且值类型还需进行装箱操作，在读取的时候执行取消装箱操作。装箱或是取消装箱以及类型的强制转换等操作，在.NET中是非常耗时的。

到了c#2.0版本，泛型被引入，初步解决了上述问题。它把参数类型变成了有T类代替，而T将在编译运行时刻，由CLR根据使用情况，用实际类型替换。泛型的使用，可以提高代码的重用率、保护类型安全和提高性能。

实现一个简单的泛型类：

using System; namespace DemoGeneric1 { /// <summary> /// 泛型类 /// </summary> public class GenericClass<T> { /// <summary> /// 泛型类型的字段 /// </summary> private T value; /// <summary> /// 泛型类型的属性 /// </summary> public T Value { get { return value; } } /// <summary> /// 带泛型参数的函数 /// </summary> /// <param name="input"></param> public void Add(T input) { this.value = input; } } class Program { static void Main(string[] args) { //使用字符串类型 GenericClass<string> str = new GenericClass<string>(); str.Add("字符串测试"); Console.WriteLine(string.Format("Value 类型：{0}", str.Value.GetType().Name)); Console.WriteLine(string.Format("Value：{0}", str.Value)); Console.WriteLine("******************************"); //使用 int 类型 GenericClass<int> intc = new GenericClass<int>(); intc.Add(123456); Console.WriteLine(string.Format("Value 类型：{0}", intc.Value.GetType().Name)); Console.WriteLine(string.Format("Value：{0}", intc.Value)); Console.ReadKey(); } } }

泛型类在.NET框架中一般用于集合类，下面的实例用于比较ArrayList和泛型<List>的执行效率。

using System; using System.Collections.Generic; using System.Collections; namespace DemoGeneric2 { class Program { static void Main(string[] args) { ArrayList arr = new ArrayList(); List<int> lst = new List<int>(); //ArrayList 计时开始 DateTime dt = DateTime.Now; //将100万个元素加入ArrayList for (int i = 0; i < 1000000; i++) arr.Add(i); //ArrayList 计时段 TimeSpan ts1 = DateTime.Now - dt; //List 计时开始 dt = DateTime.Now; //将100万个元素加入List for (int i = 0; i < 1000000; i++) lst.Add(i); //List 计时段 TimeSpan ts2 = DateTime.Now - dt; Console.WriteLine(string.Format("ArrayList 耗时：{0} ms", ts1.Milliseconds)); Console.WriteLine(string.Format("List<T> 耗时：{0} ms", ts2.Milliseconds)); Console.ReadKey(); } } }

实例的运行结果显示，泛型List的执行效率比ArrayList快了很多。

4.代理

代理是一种类型，它定义了方法签名，可以更兼容的方法关联，然后通过代理调用这些方法。代理也可以用来把参数传递给方法，比如，事件就是代理的一种，而事件处理程序就是通过代理的调用，把相关参数传递给方法。

代理类似与C++函数指针，多个方法可以绑定在一个代理上面，方法不必与代理签名完全匹配。c#2.0引入了匿名方法，允许把代码块直接绑定在代理上，而c#3.0把匿名方法升级到成lambda表达式。

代理的多种样式，下面的实例演示了代理的定义、实例化、多种形式的代理绑定。

using System; namespace DemoDelegate1 { /// <summary> /// 定义一个没有返回类型的委托 /// </summary> delegate void myDelgage(string s); /// <summary> /// 定义一个有返回类型的委托 /// </summary> delegate string myDelgageString(string s, bool man); class Program { /// <summary> /// 没有返回的方法 /// </summary> static void Show1(string s) { Console.WriteLine(string.Format(" 你好, {0}!", s)); } static void Show2(string s) { Console.WriteLine(string.Format(" 早上好, {0}!", s)); } static void Show3(string s) { Console.WriteLine(string.Format(" 晚上好, {0}!", s)); } /// <summary> /// 返回字符串的方法 /// </summary> static string AddTitle(string s, bool man) { if (man) return string.Format(" 你好, {0} 先生", s); else return string.Format(" 你好, {0} 女士", s); } static void Main(string[] args) { string name = "林晚荣"; string name2 = "徐芷晴"; //.NET 1.1 的委托实例化 myDelgage del1 = new myDelgage(Show1); Console.WriteLine(" .NET 1.1 的委托调用"); del1(name); Console.WriteLine("***********************************"); //.NET 2.0 以上的委托实例化 myDelgage del2 = Show1; Console.WriteLine(" .NET 2.0 以上的委托调用"); del2(name); Console.WriteLine("***********************************"); //多路委托绑定 Console.WriteLine(" 多路委托绑定调用"); del2 += Show2; del2 += Show3; del2(name); Console.WriteLine("/n 合并掉Show1委托调用"); del2 -= Show1; del2(name); Console.WriteLine("***********************************"); //返回类型的委托 myDelgageString del3 = AddTitle; Console.WriteLine(" 返回类型的委托调用"); Console.WriteLine(del3(name, true)); Console.WriteLine(del3(name2, false)); Console.ReadKey(); } public event myDelgage myEvet; } }

常用的代理形式，还有一种叫做事件，使用event关键字，一般的形式如下:

public event EventHandler myEvent;

事件一般定义在类中，形式类似字段定义，类型只能用代理类型，虽然是可以用任何代理类型，但根据未然的设计规范:事件处理程序的方法采用两个参数。第一个参数是System.Object类型，名为“sender”,该参数是引发事件的对象。第二个参数是System.EventArgs类型，名为“e”,该参数是与事件关联的数据。事件处理程序方法不应返回值。一个事件处理程序可以调用多个对象中的多个方法，如果允许这些方法返回值，则每个事件都将有多个返回值，并且只有调用的最后一个方法的值可用

所以，为了方便和符合微软的设计规范，事件的定义都采用EventHandler或泛型EventHandler<T>代理类型，这两个类型既符合设计规范，又能满足常用的事件的处理需要。

下面的Windows窗体应用程序实例演示了自定义事件及其事件数据类和利用代理跨线程的数据传递

类MyEventArgs.cs

using System; namespace DemoDelegate2 { /// <summary> /// 自定义的事件数据类，根据设计规范，需要从EventArgs类继承 /// </summary> public class MyEnentArgs : EventArgs { /// <summary> /// 需要传递的数据 /// </summary> public int Number { get; private set; } public MyEnentArgs(int n) { this.Number = n; } } }

在EventDemo.cs代码文件中，输入如下内容

using System; using System.Windows.Forms; using System.Threading; namespace DemoDelegate2 { public partial class EventDemo : Form { /// <summary> /// 定义事件 /// </summary> public event EventHandler<MyEnentArgs> Half;//和下面的代理，虽然名字不同，但作用类似 /// <summary> /// 定义一个用于更新界面的代理 /// </summary> /// <param name="?"></param> private delegate void UpdateCtlDelegate(int data, bool evt, bool over); public EventDemo() { InitializeComponent(); //挂载事件处理函数 this.Half += new EventHandler<MyEnentArgs>(EventDemo_Half); } /// <summary> /// 自定义事件处理函数 /// </summary> void EventDemo_Half(object sender, MyEnentArgs e) { MessageBox.Show(string.Format("参数数据:{0}", e.Number), "事件成功被引发"); } /// <summary> /// 开始按钮Click事件处理 /// </summary> private void but_Click(object sender, EventArgs e) { this.but.Enabled = false; //启动工作线程 Thread th = new Thread(new ThreadStart(progress)); th.IsBackground = true; th.Start(); } /// <summary> /// 界面更新及事件引发 /// </summary> private void update(int data, bool evt, bool over) { //检测是否需要返回界面线程 if (this.InvokeRequired) { //通过委托返回界面线程 this.BeginInvoke(new UpdateCtlDelegate(update), new object[] { data, evt, over }); return; } //循环结束修改Button显示 if (over) { this.but.Enabled = true; return; } if (evt) { //引发事件 this.Half(this, new MyEnentArgs(data)); } else { //更新进度条 this.progressBar.Value = data; } } /// <summary> /// 工作线程处理方法 /// </summary> private void progress() { for (int i = 0; i < 100; i++) { this.update(i, false, false); if (i == 50) { if (this.Half != null) this.update(i, true, false); } //延时 System.Threading.Thread.Sleep(10); } this.update(0, false, true); } } }

实例创建了工作线程来处理循环，然后通过代理来更新界面和引发事件，这个操作在WinForm程序中经常要用到。

对于自定义事件，使用泛型的EventHandler<T>代理，类型就可以采用前面定义的MyEventArags类。

5.迭代器与yield关键字

迭代器是.NET的一个重要特性，它提供了一种简单的方法来访问复杂的数据结构，在类中可以实现多个迭代器，每个迭代器和类型的成员一样有唯一的名称。

.NET1.1时代，定义迭代器非常麻烦和复杂。到了.NET2.0以后，对迭代器的编程方式进行了大幅度的改进，配合yield关键字，用极少的代码，就可以完成一个迭代器，并且很多需要实现的接口方法，编译器都会自动生成。

迭代器在LINQ中应用广泛，并且是LINQ延迟执行查询行为的基础。

yield关键字在迭代器中，用于向每句对象返回元素值或发出迭代结束信号

yield关键字的使用形式如下：

yield return <expression>;

yield break;

yield关键字只能用在定义迭代器的代码块中，yield return 返回枚举元素后，会保存迭代器的每句位置，当下次调用迭代器时，从保存的位置继续执行。

下面的控制台应用程序演示了使用yield 关键字的迭代器：

using System; using System.Collections; using System.Collections.Generic; namespace DemoIterator1 { /// <summary> /// 包含迭代器的自定义集合类 /// </summary> public class MyDocuments : IEnumerable { private List<string> docs = new List<string>(); public void Add(string s) { docs.Add(s); } #region IEnumerable 成员 public IEnumerator GetEnumerator() { foreach (string s in docs) { yield return s; } } #endregion } class Program { static void Main(string[] args) { Console.WriteLine("从包含自定义迭代器的集合类中枚举元素/n"); //初始化自定义集合 MyDocuments document = new MyDocuments(); document.Add("依莲"); document.Add("玉珈"); document.Add("徐长今"); document.Add("宁雨昔"); document.Add("安碧如"); document.Add("洛凝"); document.Add("萧玉若"); //通过带有自定义迭代器的类枚举元素 foreach (string s in document) Console.Write(string.Format(" {0} ", s)); Console.WriteLine("/n**********************************************/n"); Console.WriteLine("从自定义迭代器方法中枚举元素/n"); List<string> docs = new List<string>(); docs.Add("依莲"); docs.Add("玉珈"); docs.Add("徐长今"); docs.Add("宁雨昔"); docs.Add("安碧如"); docs.Add("洛凝"); docs.Add("萧玉若"); //通过自定义迭代器方法中枚举元素 foreach (string s in Documents(docs)) Console.Write(string.Format(" {0} ",s)); Console.ReadKey(); } /// <summary> /// 迭代器方法 /// </summary> static IEnumerable Documents(List<string> docs) { foreach (string s in docs) { yield return s; } } } }

6.隐式类型的局部变量

在与方法类似的局部环境下，c#3.0定义一个变量时，可以使用var关键字来隐式声明数据类型。

var关键字在很多语言中都有使用，例如 JavaScript、PHP等。c#的var关键字跟其他语言不同指出就是，var声明出的变量既不是一个变体、也不是一个无类型变量，而还是一个强类型变量。

编译器是通过初始化语句右侧的表达式推断出变量类型的，所以读者也可以认为var关键字是一个“语法糖”，这个语法糖，在开发LINQ查询、枚举元素的时候，是非常高效的，因为书写LINQ表达式，有时并不需要确切知道数据类型。

有了var关键字之后，推算数据类型的任务交给编译器，开发者可以专心与LINQ表达式的设计。

var关键字除了带来编程上的便利，同时也带来一个不太好的副作用，就是会给代码的可读性增加障碍，如果大量使用 var关键字，代码维护的难度将会提高。

下面的控制台应用程序DemoVar演示反编译查看用var关键字定义的变量类型

using System; using System.Collections.Generic; namespace DemoVar { class Program { static void Main(string[] args) { var str = "测试字符串"; var i = 123456; var lst = new List<string>(); var arr = new string[] { "大华军师", "金刀可汗", "圣坊仙子", "金陵才女" }; Console.WriteLine(string.Format("变量 str 的数据类型：{0}", str.GetType().Name)); Console.WriteLine(string.Format("变量 i 的数据类型：{0}", i.GetType().Name)); Console.WriteLine(string.Format("变量 lst 的数据类型：{0}", lst.GetType().Name)); Console.WriteLine(string.Format("变量 arr 的数据类型：{0}", arr.GetType().Name)); Console.ReadKey(); } } }

运行.NET Reflector后，打开项目输出的“DemoVar.exe”,找到Main函数，即可看反编译代码

7.对象和集合初始化器

在c#3.0中对象或集合初始化器由一个对象创建表达式构成。对象创建表达式不使用带参数的构造器，并且在表达式中不能引用正在初始化的对象实例。

1）对象初始化器

对象初始化器由一些成员初始化器组成，包含在花括号中间，用逗号分割，每个成员初始化器以对象的一个可访问的字段或属性开始，后面跟一个等号，之后是一个表达式，或一个对象，或一个集合初始化器。如果对性初始化器内部同一个域或属性有多个成员初始化器，将会发生错误。

成员初始化器的等号后面，表达式最终结果类型要与属性或字段的类型一致，表达式中也可以嵌套其他对象初始化器。

下面的控制台应用程序DemoInitializer1演示了对象初始化器：

using System; namespace DemoInitializer1 { class Girlfriend { public string Name { get; set; } public int Age { get; set; } } class Boy { public string Name { get; set; } public int Age { get; set; } public Girlfriend Girl{ get; set; } } class Program { static void Main(string[] args) { //用对象初始化器创建对象 Girlfriend gf1 = new Girlfriend { Name = "秦仙儿", }; //等价于 Girlfriend gf2 = new Girlfriend(); gf2.Name = "萧玉若"; gf2.Age = 21; //用嵌套的对象初始化器创建对象 Boy boy1 = new Boy { Name = "林晚荣", Age = 24, Girl = new Girlfriend { Name = "肖青漩", Age = 20 } }; //等价于 Boy boy2 = new Boy(); Girlfriend gf3 = new Girlfriend(); gf3.Name = "董巧巧"; gf3.Age = 18; boy2.Name = "林三"; boy2.Age = 24; boy2.Girl = gf3; Console.WriteLine("gf1 初始化的类型：" + gf1.GetType().Name); Console.WriteLine("boy1 初始化的类型：" + boy1.GetType().Name); Console.ReadKey(); } } }

2）

集合初始化器

如果集合实现了泛型System.Collections.Generic.ICollections<T>接口，并且指定了T的类型，那么就可以使用集合初始化器来初始化。集合出事湖区器将对每个元素调用ICollection<T>.Add(T)方法。集合初始化器由一系列包括还在花括号之间的元素初始化器构成，元素初始化器之间使用逗号进行分割。元素初始化器不能是赋值表达式

下面的控制台应用程序DemoInitializer2演示了集合初始化器既和对象初始化器的复合使用

using System; using System.Collections.Generic; namespace DemoInitializer2 { /// <summary> /// 演示对象 /// </summary> class Girlfriend { public string Name { get; set; } public int Age { get; set; } } /// <summary> /// 演示对象 /// </summary> class Boy { public string Name { get; set; } public int Age { get; set; } /// <summary> /// 集合属性 /// </summary> public List<Girlfriend> Girls { get; set;} } class Program { static void Main(string[] args) { //用集合初始化器创建集合 List<string> gfs1 = new List<string> { "肖青漩", "董巧巧", "萧玉霜" }; //等价于 List<string> gfs2 = new List<string>(); gfs2.Add("肖青漩"); gfs2.Add("董巧巧"); gfs2.Add("萧玉霜"); //对象集合初始化器复合使用 Boy boy = new Boy { Name = "林晚荣", Age = 24, Girls = new List<Girlfriend> { new Girlfriend { Name = "肖青漩", Age = 23 }, new Girlfriend { Name = "董巧巧", Age = 18 }, new Girlfriend { Name = "萧玉霜", Age = 16 } } }; Console.ReadKey(); } } }

8.匿名类型

匿名类型一般出现在LINQ的select子句中，用来投影筛选出来的数据。匿名类型使用new运算符和对象初始值设定项来创建。

匿名类型创建的属性是只读的。匿名类型的名称和属性的数据类型有编译器随机指定或自动推断。

匿名类型不允许包含除了属性以外的成员，不能牵制转换为Object以外的类型或接口，如果把匿名类型赋值给变量，必须使用var关键字来构建此变量。

多个匿名类型具有相同的顺序、相同数量和种类的属性成员，编译器会将这些匿名类型视为相同的类型，并且它们共想编译器生成的类型信息。

下面的控制台应用程序演示了DemoAnonynousType演示了不用写名字也可以创建一个类型：

using System; using System.Collections.Generic; using System.Linq; namespace DemoAnonymousType { class Program { static void Main(string[] args) { ///创建匿名类型 var anonymous1 = new { Name = "安碧如", Title = "苗族圣姑", Age = 36 }; var anonymous2 = new { Name = "宁雨昔", Title = "圣坊仙子", Age = 37 }; List<string> lst = new List<string> { "高丽公主", "大华军师", "霓裳公主" }; Console.WriteLine(string.Format("anonymous1的类型：{0}", anonymous1.GetType().Name)); Console.WriteLine(string.Format("{0} {1} {2}", anonymous1.Name, anonymous1.Title, anonymous1.Age)); Console.WriteLine(string.Format("anonymous2的类型：{0}", anonymous2.GetType().Name)); Console.WriteLine(string.Format("{0} {1} {2}", anonymous2.Name, anonymous2.Title, anonymous2.Age)); Console.WriteLine("/n*******************************************/n"); //LINQ select 子句中创建匿名类型 var query = from n in lst where n.IndexOf("公主") > -1 select new { Name = "查询元素", Title = n }; foreach (var item in query) { Console.WriteLine(string.Format("元素的类型：{0}", item.GetType().Name)); Console.WriteLine(string.Format("{0} {1}", item.Name, item.Title)); } Console.ReadKey(); } } }

对于定义的匿名类型，由于属性的类型、书序相同，所以这两个匿名类型生成的类型也是一致的。

9.扩展方法

给已存在的类型添加方法，除了继承类型外，c#3.o还提供叫做扩展方法的特性。扩展方法是一种建立在非泛型、非嵌套的静态类中的特殊的静态方法。

通用扩展方法与调用类型在类型中实际定义的方法之间没有明显的差异。扩展方法是静态方法，所以无法访问类型中的内部成员。

扩展方法的第一个参数的数据类型，决定这个方法应用与哪个类型，在数据类型的前面还需标有this关键字。

LINQ中使用大量的扩展方法，绝大多数的LINQ查询标识符都是建立在集合的扩展方法上，如Select、where等

下面控制台应用程序DemoExtensionMethods演示了不用继承对象给对象添加方法。

添加新类：MyExtensionMehtod.cs

using System; using System.Text.RegularExpressions; namespace DemoExtensionMethods { public static class MyExtensionMethod { /// <summary> /// 把UBB代码格式化成HTML链接的扩展方法 /// </summary> public static string UbbToHtmlLink(this string link) { string sp = @"(?is)/[a/](.+?)/[//a/]"; return Regex.Replace(link, sp, "<a href="/" mce_href="/""$1/">$1</a>"); } /// <summary> /// 检测是否为偶数的扩展方法 /// </summary> public static bool IsEven(this int i) { return (i % 2) == 0; } /// <summary> /// 给 Program 类增加扩展方法 /// </summary> public static void ExtensionShow(this Program p) { Console.WriteLine("从扩展方法中显示"); } } }

这个文件中定义静态类，3个扩展方法包含其中，String类型的扩展方法"UbbToHtmlLink()",这是一个使用正则表达式处理字符串的方法：Int32类型的扩展方法“IsEvent()”,用于检测数字是否是偶数，Program类型的扩展方法ExtensionShow(),Program类型将在“Program.cs”文件中定义。

Program.cs文件中的代码：

using System; namespace DemoExtensionMethods { public class Program { static void Main(string[] args) { string subb = "[a]http://www.baidu.com[/a]"; Console.WriteLine(subb.UbbToHtmlLink()); Console.WriteLine("/n"); int i = 5; Console.WriteLine(string.Format("检测 i 是否为偶数：{0}",i.IsEven())); Console.WriteLine("/n"); Program p = new Program(); p.ExtensionShow(); Console.ReadKey(); } } }

虽然例如JavaScript等很多语言都提供扩展方法，并且LINQ也是基于扩展建立的技术，但根据微软的设计准则，还是建议读者尽量不要使用扩展方法，如果有可能，推荐用继承的方法从类型派生出新类型。

扩展方法的签名如果和类型的成员方法重名，扩展方法永远不会被调用，扩展方法无法修改类型内部的源代码，所以在类型升级后，扩展方法可能会失效。

10.匿名方法和Lamdba表达式

匿名方法是一种特殊的代理，他把代码体直接关联在代理类型上，而不是常见的关联方法名。

匿名方法最早在c#2.0出现，到了c#3.0，Lamdba表达式取代了匿名方法，变成编写内联代码的首选方式。

下面的控制台应用程序DemoAnonymousMethod演示了创建匿名方法：

using System; namespace DemoAnonymousMethod { class Program { delegate void DemoDelegate(); static void Main(string[] args) { //创建匿名方法 DemoDelegate dele = delegate { Console.WriteLine("从匿名方法中输出"); }; //调用匿名方法 dele(); Console.ReadKey(); } } }

创建匿名方法，把代码体直接关联到DemoDelegate代理类。

Lambda表达式将“匿名方法”的语法进一步的简化。Lambda表达式还可以通过使用表达式木绿树动态编译代码，使得代码的运行效率进一步增强。

Lambda表达式的形式如下：（input parameters）=>expression

Lambd使用Lambda运算符“=>”,该运算符读为“goes to”.Lambda运算符的左边是可选项目：输入参数;右边是表达式或代码块。Lambda运算符与赋值运算符（=）是相同的优先级，并且也是右结合运算符。

Lambda语句的形式如下：

（input parameters）=>(statement)

Lambda语句与Lambda表达式基本一样，只是运算符“=>”右边是用花括号包含的代码块。

下面的控制台应用程序DemoLambda1演示了如何创建Lambda表达式

using System; using System.Linq.Expressions; namespace DemoLambda1 { class Program { delegate string MyDelegate(string title, string name); //delegate T MyDelegate2<T>(T a, T b); static void Main(string[] args) { //定义Lambda表达式 MyDelegate dele = (title, name) => string.Format("{0} {1}", title, name); Console.WriteLine("调用Lambda表达式/n"); //调用Lambda表达式 Console.WriteLine(dele("出云公主", "肖青漩")); Console.WriteLine(dele("乖巧人儿", "董巧巧")); Console.WriteLine(dele("萧家二小姐", "萧玉霜")); Console.WriteLine("/n*******************/n"); string tmp = "我是Lambda语句外的变量"; //定义Lambda语句 MyDelegate dele2 = (title, name) => { Console.WriteLine("从Lambda语句体中输出"); Console.WriteLine(string.Format("输出外部变量tmp：{0}", tmp)); string s; s = string.Format("{0} {1} 小姐", title, name); return s; }; Console.WriteLine("调用Lambda语句/n"); //调用Lambda表达式 Console.WriteLine(dele2("霓裳公主", "秦仙儿")); Console.ReadKey(); } } }

在Lambda的语句中可以调用语句外的变量，语句内的变量则不能被外面调用，语句内的变量直到关联的代理超出范围才会被垃圾回收器回收。

Lambda表达式目录树是Lambda表达式以树形的形式表现出来的一种数据结构。它是泛型System.Linq.Expressions.Expression<TDelegate>的实例。TDelegate代理类型即可以使用.NET Framework3.5中预定义Func系列代理类型，也可以使用自己定义的代理类型。

Lambda表达式目录树把Lambda表达式分解成树形结构，这主要是为了创建IQueryable LINQ提供程序、优化Lambd表达式、提高执行效率。

下面的控制台应用程序DemoLambda2演示了创建Lambda表达式树：

using System; using System.Linq.Expressions; namespace DemoLambda2 { class Program { static void Main(string[] args) { //定义Lambd表达式目录树 Expression<Func<int, bool>> tree = n => n > 168; //分解表达式 BinaryExpression body = (BinaryExpression)tree.Body; ParameterExpression left = (ParameterExpression)body.Left; ConstantExpression right = (ConstantExpression)body.Right; //分解结果 Console.WriteLine("分解结果: {0} {1} {2}/n", left.Name, body.NodeType, right.Value); //编译目录树 Func<int, bool> t = tree.Compile(); //执行目录树 Console.WriteLine(string.Format("1000 是否大于 168 :{0}", t(1000))); Console.ReadKey(); } } }

Lambda表达式目录树负责分解、优化Lambda表达式，一般开发者只要大致了解就可以，它很少有实际应用的时候。

哈哈，最后再看个综合实例：c#高亮编辑及编译运行器

这个综合实例使用上面讲解的自动属性、扩展方法、集合初始化器、代理、隐藏类型的局部变量、Lambda

创建DemoCSharpEditor的Windows窗体应用程序

在项目中添加名称为“CurrentWord.cs”的类，代码如下：

using System; namespace DemoCSharpEditor { /// <summary> /// 光标所在的词 /// </summary> public class CurrentWord { /// <summary> /// 起始位置 /// </summary> public int StartIndex { get; set; } /// <summary> /// 结束位置 /// </summary> public int Length { get; set; } /// <summary> /// 词 /// </summary> public string Word { get; set; } } }

这是一个数据存储类，有3个自动属性，用来存储检索到的词。

在项目中添加名称为“EditorExtension.cs”的类，输入下面的代码：

using System; using System.Linq; namespace DemoCSharpEditor { /// <summary> /// String 扩展 /// </summary> public static class EditorExtension { /// <summary> /// 单词分隔字符数组 /// </summary> public static char[] SplitChar = { ' ', ',', '.', ';', '/n', '{', '}', '/r', Convert.ToChar(9),'(',')','[',']' }; /// <summary> /// 检测字符是否分割字符 /// </summary> public static bool IsSplit(this Char chr) { var query = SplitChar.Where(c => c == chr); if (query.Count<char>() > 0) return true; else return false; } /// <summary> /// 检测字符串最后一个字符是否是分割字符 /// </summary> public static bool LastCharIsSplit(this string str, int cursorinde) { if (cursorinde < 1) return false; var sec = from c in SplitChar where c == str[cursorinde - 1] select c; if (sec.Count<char>() > 0) return true; else return false; } /// <summary> /// 光标所在的单词 /// </summary> public static CurrentWord CursorWord(this string str, int cursorindex) { if (string.IsNullOrEmpty(str)) return null; if (cursorindex < 2) return null; int i = str.LastIndexOfAny(SplitChar, cursorindex - 2); int ed = cursorindex - 2; if (ed < 1) ed = str.Length; if (i < 0) i = 0; else i = i + 1; if (ed < str.Length) { //光标不在字符串尾部,向后搜索 ed = str.IndexOfAny(SplitChar, ed); } if (ed < 0) return null; char lastc = str[ed - 1]; if (lastc.IsSplit()) ed = ed - 1; ed = ed - i; if (ed < 1) return null; return new CurrentWord { StartIndex = i, Length = ed, Word = str.Substring(i, ed) }; } } }

这是一个静态类，定义了3个扩展方法，作用就是返回字符串中光标位置上的单词。

在项目中添加名称为“EditorController.cs”类，代码如下：

using System; using System.Collections.Generic; using System.Linq; using System.Windows.Forms; using System.IO; using System.Drawing; using System.CodeDom.Compiler; using Microsoft.CSharp; using System.Reflection; namespace DemoCSharpEditor { /// <summary> /// 控制器 /// </summary> public class EditorController { /// <summary> /// 高亮字颜色 /// </summary> public Color LightColor { get; set; } /// <summary> /// 文本色 /// </summary> public Color TextColor { get; set; } /// <summary> /// RichTextBox 控件引用 /// </summary> private RichTextBox rich; private TextBox loginfo; /// <summary> /// 关键字列表 /// </summary> private List<string> keywords = new List<string>(); public EditorController(RichTextBox r, TextBox l) { if (r == null || l == null) throw new Exception("控制器，初始化失败。"); this.loginfo = l; this.rich = r; this.rich.KeyUp += new KeyEventHandler(rich_KeyUp); this.LoadKeyWord(); this.LightColor = Color.Blue; this.TextColor = this.rich.ForeColor; } void rich_KeyUp(object sender, KeyEventArgs e) { if (e.KeyValue < 229) this.LightCurrentKeyWord(); } /// <summary> /// 从文本文件装载关键字列表 /// </summary> private void LoadKeyWord() { string sf = "cs.txt"; if (File.Exists(sf)) { keywords.Clear(); using (StreamReader sr = new StreamReader(sf)) { string sl = sr.ReadLine(); do { if (sl != null) keywords.Add(sl); sl = sr.ReadLine(); } while (sl != null); } } } /// <summary> /// 高亮关键字 /// </summary> private void LightCurrentKeyWord() { CurrentWord last = this.rich.Text.CursorWord(this.rich.SelectionStart); if (last != null) { var query = from w in this.keywords where w == last.Word select w; int oldindex = this.rich.SelectionStart; int oldleng = this.rich.SelectionLength; this.rich.SelectionStart = last.StartIndex; this.rich.SelectionLength = last.Length; if (query.Count<string>() > 0) { this.rich.SelectionColor = this.LightColor; } else { this.rich.SelectionColor = this.TextColor; } this.rich.SelectionLength = oldleng; this.rich.SelectionStart = oldindex; this.rich.SelectionColor = this.TextColor; } } /// <summary> /// 格式化代码 /// </summary> private string MakeCode() { string code = @" using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; namespace DemoTest { public class Test { public void TestMethod() {" + this.rich.Text + @" } } }"; return code; } /// <summary> /// 编译并运行代码 /// </summary> public void Compile() { this.loginfo.Text = "信息：准备编译。/n"; using (CSharpCodeProvider provider = new CSharpCodeProvider()) { string[] refs = { "System.dll", "System.Data.dll", "System.Deployment.dll", "System.Drawing.dll", "System.Windows.Forms.dll", "System.Xml.dll" }; CompilerParameters opt = new CompilerParameters(); opt.ReferencedAssemblies.AddRange(refs); CompilerResults res = provider.CompileAssemblyFromSource(opt, this.MakeCode()); if (res.Errors.Count > 0) { foreach (CompilerError e in res.Errors) this.loginfo.AppendText(string.Format("编译错误：{0}/n", e.ErrorText)); return; } this.loginfo.AppendText("信息：编译成功，准备运行。/n"); try { Assembly assembly = res.CompiledAssembly; Type type = assembly.GetType("DemoTest.Test"); object obj = Activator.CreateInstance(type); this.loginfo.AppendText("信息：运行。/n"); type.GetMethod("TestMethod").Invoke(obj, null); } catch (Exception e) { this.loginfo.AppendText(string.Format("运行错误：{0} /n {1} /n", e.Message, e.StackTrace)); } this.loginfo.AppendText("完毕。/n"); } } } }

这个控制器类，初始化的时候，传入RichTextBox控件，关联上KeyUp事件，通过检测光标附近的单词是否在关键字列表中，如果是关键字，就是用RichTextBox属性，将关键字颜色设置为LightColor属性值，如果不是关键字，设置为TextColor属性值。

界面Editor.cs的代码如下：