0、语法糖简介

语法糖(Syntactic sugar)，也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。

它可以使程序员更加容易去使用这门语言：操作可以变得更加清晰、方便，或者更加符合程序员的编程习惯。

简而言之，语法糖就是一种便捷写法。

1、自动属性

未简化：手写私有变量+公有属性

private string _name;
public string Name
{
	get { return _name; }
	set { _name = value; }
}

简化：声明空属性，编译器自动生成对应私有成员字段。

public string Name { get; set; }

2、参数默认值和命名参数

使用的指导原则：
1、可以为方法和有参属性指定默认值
2、有默认值的参数，必须定义在没有默认值的参数之后
3、默认参数必须是常量
4、ref和out参数不能指定默认值

public class User
{
	public string Name { get; set; }
	public int Age { get; set; }

	// 自动属性默认初始化
	public string Address { get; set; } = "江苏";

	// 设置参数默认值（age）
	public User(string name, string address, int age = 18)
	{
		this.Name = name;
		this.Age = age;
		this.Address = address;
    }
}

// 命名参数（指定address参数）
User user = new User("小王",address:"苏州");

3、类型实例化

// 使用对象初始化器:{},使用对象初始化器，必须提供一个无参的构造函数,可以只给部分属性初始化
User user = new User()
{
 	Name = "小王",
	Age = 18,
	Address = "苏州",
 };

4、集合

4.1 初始化List集合的值

// 简化之前
List<string> listString = new List<string>();
listString.Add("小王");
listString.Add("小贤");

// 简化后
List<string> listString = new List<string>() {
	"小王",
	"小贤",
};

4.2 取List中的值

// 简化之前
foreach (string str in listString)
{
	Console.WriteLine(str);
}
// 简化之后
listString.ForEach(s => Console.WriteLine(s));

5、隐式类型（var）

程序员在声明变量时可以不指定类型，由编译器根据值来指定类型
var定义变量有以下四个特点：
1、必须在定义时初始化
2、一旦初始化完成，就不能再给变量赋与初始值不同类型的值了
3、var要求是局部变量
4、使用var定义变量和object不同，它在效率上和使用强类型方式定义变量完全一样

// 1.隐式类型在定义时必须初始化
//var name; 报错
var name = "小王";
// 2.可以用同类型的其他隐式类型变量来初始化新的隐式类型变量
var age = 18;
var ageTwo = age;
// 3.也可以用同类型的字面量来初始化隐式类型变量
var name1 = "小王";
name1 = "小贤";
// 4.隐式类型局部变量还可以初始化数组而不指定类型
var array = new List<string>() { "小王", "小贤", };

6、扩展方法【更换测试实例】

扩展方法使你能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。扩展方法是一种特殊的静态方法，但可以像扩展类型上的实例方法一样进行调用。
注意：定义扩展方法的类必须和使用地方的类命名空间相同(如果不同命名空间记得先引入命名空间,下边示例在一个命名空间中)

using System;

namespace ConsoleApp1
{
    public static class ExtensionString
    {
        //向 String 类扩展一个统计单词数量的方法
        public static int CountWord(this string str)
        {
            return str.Split(' ').Length;
        }
        // 为string 添加一个扩展方法（判断string是否为空||null）
        public static bool IsEmpty(this string str)
        {
            return string.IsNullOrEmpty(str);
        }
    }

    public class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("单词数量:" + "Hello World".CountWord()); //没有参数
            Console.WriteLine("是否为空/null:" + "Hello World".IsEmpty()); //没有参数

            Console.ReadLine();
        }
    }
}

7、匿名类型（Anonymous type）【待补充】

8、匿名方法（Anonymous methods）【待补充】

9、dynamic动态对象

.net4.0中引入了一个新类型 dynamic.该类型是一种静态类型，但类型为 dynamic 的对象会跳过静态类型检查。大多数情况下，该对象就像具有类型 object 一样.在编译时，将假定类型化为 dynamic 的元素支持任何操作。

dynamic dy = "string";
Console.WriteLine(dy.GetType());
//输出：System.String
dy = 100;
Console.WriteLine(dy.GetType());
//输出：System.Int32

10、字符串嵌入值

c#6.0后新增的特性 $，用于代替string.Format(“”)

// 之前
var str = string.Format("时间：{0}", DateTime.Now);
Console.WriteLine(str);
// 改进
var str1 = $"时间：{DateTime.Now}";
Console.WriteLine(str1);

11、问号(?)表达式

11.1 可空类型修饰符(?)

引用类型可以使用空引用表示一个不存在的值，而值类型通常不能表示为空。

string str = null;// 正确
//int i = null; // 错误

为了使值类型也可为空，就可以使用可空类型，可以使用 Nullable泛型结构来定义，但是微软为了语法更简洁，提供了?运算符来定义可空类型，二者效果是一样的，基本语法如下：

值类型? 变量名=值;

// 这二种定义可空类型的方法都是对的，但是？更简洁
Nullable<int> intOne = 5;
int? intTwo = 5;

11.2 三元（运算符）表达式（?: )

int gender = 1;
string str = gender == 1 ? "男" : "女";

11.3 合并运算符(??) 【和 ??=】

合并运算符使用??表示，当进行转换时，如果可空类型的值为 null，则使用默认值。

int? intA = null;
int intB = 100;
intB = intA ?? 0;//此处intA为null，则将0赋值给intB

int? intC = 500;
intB = intC ?? 0;//此处intC不为null，则将500赋值给intB

11.4 NULL检查运算符（?.）

C# 6.0中，引入了 ?. 的运算符，可帮助编写更少的代码来处理 null 检查
如果对象为NULL，则不进行后面的获取成员的运算，直接返回NULL

string str = "abcd";
string s1 = null;
Console.WriteLine(str?.Length);// 输出 4
Console.WriteLine(s1?.Length);// 输出空

11.5 （?[]）运算符【待补充】

12、使用完毕后自动释放资源(using || try finally)

为了节约资源，每次使用完毕后都要释放掉资源，其中可以使用using和try finally来进行释放资源操作。需要注意的是使用using释放资源的对象都必须继承IDisposable接口（MSDN）。

// try finally 写法
SqlConnection conn = null;
try
{
	conn = new SqlConnection("数据库连接字符串");
	conn.Open();
}
finally
{
	conn.Close();
	conn.Dispose();
}

// Using写法
using (SqlConnection conn=new SqlConnection("数据库连接字符串"))
{
      conn.Open();
}

13、委托

13.1 基本用法

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

class MyClass
{
	//定义委托
	public delegate void TestDelegate(string str);
	//定义委托方法
	public void Method(string str)
	{
		Console.WriteLine(str);
	}
	public void UseDelegate(TestDelegate d, string str)
	{
		d(str);
	}
}

//调用委托
MyClass mc = new MyClass();
//调用定义的委托方法
mc.UseDelegate(new MyClass.TestDelegate(mc.Method), "Hello!");

//使用匿名委托
mc.UseDelegate(delegate(string str)
{
	Console.WriteLine(str);
}, "Hello!");
            
//使用Lambda表达式
mc.UseDelegate(s =>
{
	Console.WriteLine(s);
}, "Hello!");

13.2内置委托【重要】

CLR环境中给我们内置了几个常用委托Action、 Action＜T＞、Func＜T＞、Predicate＜T＞，一般我们要用到委托的时候，尽量不要自己再定义一 个委托了，就用系统内置的这几个已经能够满足大部分的需求，且让代码符合规范。

查看该博客了解更多：C#委托Action、 Action＜T＞、Func＜T＞、Predicate＜T＞

14、Lambda表达式【待补充】

15、Linq【待补充】

参考：https://blog.csdn.net/boyyus/article/details/100638651