C#中的语法糖

原地址 https://www.cnblogs.com/yukaizhao/archive/2010/05/25/csharp-Syntactic-sugar.html

https://www.cnblogs.com/dotnet261010/p/6055092.html

首先需要声明的是“语法糖”这个词绝非贬义词，它可以给我带来方便，是一种便捷的写法，编译器会帮我们做转换；而且可以提高开发编码的效率，在性能上也不会带来损失。这让java开发人员羡慕不已，呵呵。

 

1．  经过简化的Property

早些时候我们这样声明Property

1 2 3 4 5 6 7 8 9 10 11

private string _myName;   public string MyName   {       get { return _myName; }       set { _myName = value; }   }

千篇一律的这样声明，没有多大意义，于是C#的设计人员将这个千篇一律的工作交给了编译器帮我们做了，我们现在可以这样声明

1	public string MyName { get; set; }

当然他不会牺牲灵活性，我们可以单独给get或者set设定访问限制符，例如

1	public string MyName { get; protected internal set; }

 

2．  经过两次变异的委托写法

在.net 1.1时我们不得不声明方法后才在委托中使用，在.net 2.0之后我们可以使用匿名委托，他不单可以简化写法，还可以在匿名委托中访问范围内的变量；再后来拉姆达表达式来了，写法就更简便了。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

class MyClass {     public delegate void DoSomething(int a);       //定义方法委托     private void DoIt(int a) {         Console.WriteLine(a);     }       private void HowtoDo(DoSomething doMethod,int a) {         doMethod(a);     }       public static void Main(string[] args) {         MyClass mc = new MyClass();         //调用定义的方法委托         mc.HowtoDo(new DoSomething(mc.DoIt), 10);         int x = 10;         //使用匿名委托         mc.HowtoDo(delegate(int a){             Console.WriteLine(a + x);         },10);           //使用lamda表达式         mc.HowtoDo(a=>Console.WriteLine(a+x),10);           Console.ReadLine();     } }

3．  集合类的声明

之前我们声明一个List并给list赋初始值，必须得这么写：

1 2 3 4

List<string> list = new List<string>(); list.Add("a一"); list.Add("b二"); list.Add("c三");

现在不需要了，直接写就可以了

1 2 3

List<string> list = new List<string> {             "def","OK" };

 

4．  集合类各个项的操作

我们为了逐个处理集合中的项，需要这么写：

1 2 3 4

foreach (string item in list) {      Console.WriteLine(item); }

现在不需要了，这样就可以了

1	list.ForEach(a => Console.WriteLine(a));

代码是不是清爽了很多。

 

5．  using == try finally

为了在使用完毕时释放资源，我们经常要用using，using实质上就是try fiannaly的一个语法糖而已。例如

1 2 3 4 5 6 7 8 9

StreamWriter sw = null; try {     sw = new StreamWriter("d:\abc.txt");     sw.WriteLine("test"); } finally {     if(sw!= null) sw.Dispose(); }

上面的代码可以简化为：

1 2 3

using (var sw = new StreamWriter("d:\abc.txt")) {     sw.WriteLine("test"); }

6．  可爱的var

var的意义时不必写声明的类型，编译器会根据后面对var的赋值判断它的类型，var的类型一旦确认就不能再改变，它只能作为局部变量使用，不能用做字段也不能用做参数声明。

例如：

1	var writer = new StreamWriter(path);

1	for(var i=0;i<100;i++){}

 

7．  问号的演变

老掉牙的一个问号+冒号

1 2	var b = 3; var a = b > 9?b.ToString():”0”+b;

新宝宝两个问号 ??，它表示左边的变量如果为null则值为右边的变量，否则就是左边的变量值

1 2	string a = null; var b = a??””;

1. 可空类型修饰符（？）
引用类型可以使用空引用表示一个不存在的值，而值类型通常不能表示为空。 
例如：string str=null; 是正确的，int i=null; 编译器就会报错。 
为了使值类型也可为空，就可以使用可空类型，即用可空类型修饰符"？"来表示，表现形式为"T？" 
例如：int? 表示可空的整形，DateTime? 表示可为空的时间。 
T? 其实是System.Nullable(泛型结构）的缩写形式，
也就意味着当你用到T？时编译器编译时会把T？编译成System.Nullable的形式。 
例如：int?,编译后便是System.Nullable的形式。 
  
2. 三元（运算符）表达式（?:)
 例如：x?y:z 表示如果表达式x为true，则返回y；
如果x为false，则返回z，是省略if{}else{}的简单形式。  

3. 空合并运算符(??)
用于定义可空类型和引用类型的默认值。
如果此运算符的左操作数不为null，则此运算符将返回左操作数，否则返回右操作数。
例如：a??b 当a为null时则返回b，a不为null时则返回a本身。 
空合并运算符为右结合运算符，即操作时从右向左进行组合的。
如，“a??b??c”的形式按“a??(b??c)”计算。

4.NULL检查运算符（?.） 

　　例如我们要获取一个Point序列的第一个点的X坐标，第一感觉会这么写：

    int firstX = points.First().X;

　　但是，老鸟会告诉你，这儿没有进行NULL检查，正确的版本是这样的：

   int? firstX = null;    
   if (points != null)     
   {  
    var first = points.FirstOrDefault();   
     if (first != null)        
     firstX = first.X;   
   } 

　　正确倒是正确了，代码取变得难读多了。在C# 6.0中，引入了一个 ?. 的运算符，前面的代码可以改成如下形式：

    int? firstX = points?.FirstOrDefault()?.X;

　　从这个例子中我们也可以看出它的基本用法：如果对象为NULL，则不进行后面的获取成员的运算，直接返回NULL

　　需要注意的是，由于"?."运算符返回的可以是NULL，当返回的成员类型是struct类型的时候，"?."和"."运算符的返回值类型是不一样的。

     Point p = new Point(3, 2);    

　　 Console.WriteLine(p.X.GetType() == typeof(int));        //true    

 　　Console.WriteLine(p?.X.GetType() == typeof(int?));        //true

 5"?[]"运算符：

    int? first = customers?[0].Orders.Count();

（这个不太清楚，感觉微软语法糖用过头了。）

本质：都使用了语法糖，在编译阶段编译器会把特殊符号先转译成原始状态再编译。

 

8．  类型实例化的语法糖

1 2 3 4 5 6 7 8

public class Abc {     public int ID { get; set; }       public string Name { get; set; }       public string Url { get; set; } }

我们没有为上面的类声明构造函数，但是我们可以像下面的形式来实例化它

1 2 3 4 5 6 7

public static void Main(string[] args) {         var abc = new Abc{             ID=1,             Name="yukaizhao",             Url="http://yukaizhao.cnblogs.com/"         };     }

 /// <summary>
29         /// 默认参数
30         /// </summary>
31         /// <param name="name"></param>
32         /// <param name="loginName"></param>
33         /// <param name="age"></param>
34         /// <param name="address"></param>
35         /// <param name="password"></param>
36         public User(string name,string loginName,int age,string address="上海",string password="1234")
37         {
38             this.Name = name;
39             this.LoginName = loginName;
40             this.Age = age;
41             this.Address = address;
42             this.Password = password;
43         }

 User user3 = new User("小红", "xiaohong", 28,password:"5678");

 

 

10.  传说中的扩展方法

在c#3.5时引入了扩展方法，我们可以在不修改类源码的情况下给类增加实例方法，这个很有意义。它的实质也是一种语法糖的实现

例如我们给String类扩展一个IsNumber的方法：

1 2 3 4 5 6 7 8 9 10 11

public static class StringExt {     static private Regex regexNumber = new Regex("\\d+");     static public bool IsNumber(this string input)     {         if (string.IsNullOrEmpty(input))         {             return false;         }         return regexNumber.IsMatch(input);     } }

我们可以在String实例上调用这个方法了

1 2	var abc = “123”; var isNumber = abs.IsNumber();

 

11．使用匿名类

1 2 3

var a = new {     ID = 1,Name=”yukaizhao”,BlogUrl=”http://www.cnblogs.com/yukaizhao/” };

匿名类在linq to sql或者entity framework中返回查询数据时很好用。

 

现在定义一个匿名对象来表示一个人
var aPeople=new {pName="张三",pAge=26,pSex="男"};
现在我们就可以使用属性语法获取和设置对象的各个变量
aPeople.pAge=29;
Console.WriteLine("{0} is {1}years old",aPeople.pName,aPeople.pAge);
匿名类型的嵌套
    刚刚我们定义了表示一个人的匿名类型，现在我们定义一个表示雇员的嵌套匿名类型：
    var Aemployee=new {
        JoinDate="2012-09-23",
        aPeople=new {pName="张三",pAge=26,pSex="男"},
        title=Manager
    };

12. Func<>   Predicate<>  Action<>

Action<>泛型参数无返回值委托

Predicate<>泛型参数，Bool返回值委托，多用于数组查询

Func<>泛型参数和返回值委托。