[C#] C#3、LINQ 及相關特性

1. 屬性的自動實現

在 C#3 以前，每個屬性需要手動實現，也就是需要手動為屬性添加 get 訪問器與 set 訪問器，如：

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

在 C#3 以後，可以透過自動實現的方式撰寫：
- 其中命名為 name 的變數由編譯器自動創建並為其賦予名稱。

public string Name { get; set; }

但在 C#3 時，不能宣告 readonly 的自動屬性，且不能在宣告時賦予初始值，在 C#6 做了修正。在 C#3 只能透過訪問子分離來模擬 readonly：

public string Name { get; private set; }

2. 隱式類型(var)

靜態類型 vs. 動態類型：
- 靜態類型是面向編譯的的語言，故所有類型由編譯器決定，在編譯期就會完成綁定。
- 動態類型則是延遲綁定的時間，在執行期才進行類型綁定。
顯式類型 vs. 隱式類型：
- 顯式類型代表在程式碼表達式便給出具體的類型訊息。
- 隱式類型則允許了類型推斷，透過上下文判斷出類型．
C#3 開始支援隱式類型的寫法，關鍵字是 var。
```
var name = "Rainhu";
// string name = "Rainhu"
```
- 隱式類型的宣告有幾個限制：
  1. 變數必須在宣告時就初始化。
  2. 用於初始化的表達式必須已具備某個類型。
  3. 只能用於局部變數
```
var x;
x = 10;         // 違反1

var y = null;   // 違反2
```
- 特別注意到：C# 是在編譯期就完成隱式類型的綁定
隱式類型因為其方便性，但很容易造成濫用，其適用的情形大致如下：
1. 變數為匿名類型，不能為其指定類型。
2. 變數的型別過長，並且初始化表達式就足以用來推斷。
3. 變數的精確類型不重要，並可以透過初始化表達式來推斷。
```
Dictionary<string, List<decimal>> mapping = new Dictionary<string List<decimal>>();
var mapping = new Dictionary<string, List<decimal>>();
```

隱式類型的數組

int[] arr = new int[10];
int[] arr1 = { 1, 2, 3, 4, 5 };
int[] arr2 = new int[] { 1, 2, 3, 4, 5 };

int[] arr3;
arr3 = {1, 2, 3, 4, 5}      // 非法
arr3 = new[] { 1, 2, 3, 4, 5 };

物件與集合的初始化

以電子商務系統為例

public class Order
{
    private readonly List<OrderItem> items = new List<OrderItem>();
    public string OrderId { get; set; }
    public Customer Customer { get; set; }
    public List<OrderItem> Items { get { return items; }}
    public void Add(OrderItem item)
    {
        items.Add(item);
    }
}
public class Customer
{
    public string Name { get; set; }
    public string Address { get; set; }
}
public class OrderItem
{
    public string ItemId { get; set; }
    public int Quantity { get; set; }
}

若不使用物件初始化器與集合初始化器便會像：

var customer = new Customer();
customer.Name = "Mike";
customer.Address = "Japan";

var item1 = new OrderItem();
item.ItedId = "item12345";
item.Quantity = 1;

var item2 = new OrderItem();
item.ItedId = "item54321";
item.Quantity = 2;

var order = new Order();
order.OrderId = "order12345";
order.Customer = customer;
order.Items.Add(item1);
order.Items.Add(item2);

若使用物件初始化器與集合初始化器，便可大大增加可讀性，並且在接下來的 LINQ 上有大大的好處：

var order = new Order
{
    OrderId = "order12345",
    Customer = new Customer { Name = "Mike", Address = "Japan" },
    Items = 
    {
        new OrderItem { ItemId = "item12345", Quantity = 1 },
        new OrderItem { ItemId = "item54321", Quantity = 2 }
    }
}

3. 匿名類型

前面說到隱式類型，好像是可有可無的存在，但在匿名類型，就是一個只能用隱式類型來宣告的情況了。

匿名類型的宣告：

var procuct
{
    Name = "CD Pro-2",
    Price = 50000
}
string name = product.Name;
int price = product.Price;

搭配隱式類型數組的匿名類型宣告：

var products = new[]
{
    new { Name = "CD Pro-2", Price = 50000 },
    new { Name = "iDream", Price = 100000 },
    new { Name = "Forsung TV", Price = 150000 }
}

4. lambda 表達式

基本語法

lambda 表達式的基本語法為：參數列表 => 主體
- 與之前的匿名方法類似，只是將 delegate 換成了 =>
```
Action<string> action = (string msg) =>
{
    Console.WriteLine(msg);
};
action("hello world!");
```
- 但在主體包含的內容很短時，可以簡化成：
```
Action<string> action = (string msg) => Console.WriteLine(msg);
```
- 參數列表若可以經由類型推斷，那麼可以進一步簡化成：
```
Action<string> action = (msg) => Console.WriteLine(msg);
```
- 參數列表只有一個參數，括號也可以省略：
```
Action<string> action = msg => Console.WriteLine(msg);
```

捕獲變數

對開發者而言，lambda 表達式除了可以使用自於的參數列表外，還可以捕捉靜態變數、物件實例、this變數、方法參數或局部變數，後者全部都為捕獲變數，而根據不同的作用域，編譯器會為其編譯成相對應的 IL code。

在此提供一個以生成類來實現的例子：

public Action<string> CreateAction(string methodParameter)
{
    string methodLocal = "method Local";
    string uncaptured = "uncaptured";

    Action<string> action = lambdaParameter =>
    {
        string lambdaLocal = "lambda local";
        Console.WriteLine("Instance field: {0}", instanceField);
        Console.WriteLine("Method Parameter: {0}", methodParameter);
        Console.WriteLine("Method Local: {0}", methodLocal);
        Console.WriteLine("Lambda parameter: {0}", lambdaParameter);
        Console.WriteLine("Lambda local: {0}", lambdaLocal);
    };
    methodLocal = "modified method local";
    return action;
}

經轉譯後的程式碼

private class LambdaContext
{
    public CapturedVariable original;
    public string methodParameter;
    public string methodLocal;
    public void Method(string lambdaParamter)
    {
        string lambdaLocal = "lambda local";
        Console.WriteLine("Instance field: {0}", instanceField);
        Console.WriteLine("Method Parameter: {0}", methodParameter);
        Console.WriteLine("Method Local: {0}", methodLocal);
        Console.WriteLine("Lambda parameter: {0}", lambdaParameter);
        Console.WriteLine("Lambda local: {0}", lambdaLocal);
    }
}
public Action<string> CreateAction(string methodParameter)
{
    LambdaContext context = new LambdaContext();
    context.original = this;
    context.methodParameter = methodParameter;
    context.methodLocal = "method Local";
    string uncaptured = "uncaptured local";

    Action<string> action = context.Method;
    context.methodLocal = "modified method local";
    return action;
}

5. 擴展方法 Extension Method

擴展方法是一種靜態方法，可以對其第一個參數的類型物件以物件的方式進行調用：
```
SampleClass.Method(x,y);
x.Method(y);
```

宣告方式：

using System;
namespace Battle.Extensions
{
    public static class BattleExtensions
    {
        public static void Attack(this Warrior Alpha, Warrior Delta)
        {
            Battle.Attack(Alpha, Delta);
        }
    }
}

調用方式

Warrior Alpha = new Warrior
{
    Name = "Alpha",
    Level = 5,
    Attack = 10,
    HP = 20
};
Warrior Delta = new Warrior
{
    Name = "Delta",
    Level = 5
    Attack = 8,
    HP = 25
};
// 原始版本
Battle.Attack(Alpha, Delta);
// 擴充方法版本
Alpha.Attack(Delta);

編譯器唯一需要做的是為擴展方法及其所在類添加[Extension]特性。該特性在命名空間System.Runtime.CompileServices下。本質上是一個標記，標記擴充方法。

6. LINQ 查詢

接著我們可以透過 lambda 表達式與擴充方法來進行鏈式調用：

Warrior Alpha = { Name = "Alpha", Level = 5, Attack = 10, HP = 20 };
Warrior Beta =  { Name = "Beta",  Level = 3, Attack =  6, HP = 12 };
Warrior Gamma = { Name = "Gamma", Level = 5, Attack = 12, HP = 18 };
Warrior Delta = { Name = "Delta", Level = 5, Attack =  8, HP = 25 };
Warrior[] warriors = { Alpha, Beta, Gamma, Delta };
IEnumerable<string> query = warriors
    .Where(warrior => warrior.Level >= 5)
    .OrderBy(warrior => warrio.Name)
    .Select(warrior => warrior.Name.ToUpper());   
    // ["ALPHA", "DELTA", "GAMMA"]

若沒有使用 IEnumerable 的擴充方法，會長這樣，可讀性整個就下降了：

Warrior[] warriors = { Alpha, Beta, Gamma, Delta };
IEnumerable<string> query = 
    Enumerable.Select(
        Enumerable.OrderBy(
            Enumerable.Where(warriors, warrior => warrior.Level >= 5),
            warrior => warrior.Name,
        ),
        warrior => warrior.Name.ToUpper());

LINQ 還可以使用查詢表達式：

IEnumerale<string> query = from warrior in warriors
                           where warrior.Level >= 5
                           orderby warrior.Name
                           select warrior.Name.ToUpper();

甚至可以利用 let 引入新的變數

IEnumerale<string> query = from warrior in warriors
                           let name = warrior.Name
                           where warrior.Level >= 5
                           orderby name
                           select name.ToUpper();

1. 屬性的自動實現#

2. 隱式類型(var)#

3. 匿名類型#

4. lambda 表達式#

基本語法#

捕獲變數#

5. 擴展方法 Extension Method#

6. LINQ 查詢#