函式傳遞的進化論 (4) - lambda expression

前面講到了delegate(委派)的語法，不過使用上還是有些繁瑣。
除了要宣告委派類別外，同樣必須要先宣告與定義符合委派類別的方法才可以使用。

public delegate int Calculator(int a, int b);
 
public class Operator
{
 public static int Plus(int a, int b)
 {
  return a + b;
 }
 
 public static int Sub(int a, int b)
 {
  return a - b;
 }
 public static int Mul(int a, int b)
 {
  return a * b;
 }
 
 public static int Div(int a, int b)
 {
  return a / b;
 }
}

public static void Main()
{
    var calc = new Calculator(Operator.Plus);
    Console.WriteLine(calc(3,5));
 
    calc = new Calculator(Operator.Sub);
    Console.WriteLine(calc(3,5));
}

如你所見，有時候我們只是需要很簡單的方法(僅僅1-2行)或是該方法僅僅只使用個1-2次，但是卻需要額外宣告方法以及包覆的類別(如Operator類別)。
那麼有沒有更簡便的寫法呢？
有，C#有提供匿名方法(Anonymous Method)的方式讓我們可以省下方法的宣告：

public delegate int Calculator(int a, int b);
public static void Main()
{
 Calculator calc = delegate(int a, int b)
 {
  return a+b;
 };
 Console.WriteLine(calc(3,5));
 
}

在第4行時就是使用匿名方法的方式，直接定義出一個方法以及其主體(return a + b)。
如此在使用委派時就可以隨時定義出想使用的方法。


不過...這樣就結束了嗎？ 還沒呢！！ C#還提供更懶人的方式：Lambda Expression

public delegate int Calculator(int a, int b);
public static void Main()
{
 Calculator calc = (int a, int b) => { return a+b; };
 
 Console.WriteLine(calc(3,5));
}

第4行的(int a, int b) => { return a+b; }; 即是lamdba expression。
左邊的 (int a, int b) 表示方法的輸入參數，
中間的 => 即是lamdba expression的關鍵語法。
右方的 { return a+b; } 則是方法的主體。
整體來說這跟匿名方法有些相似，同樣都沒有方法名稱、輸入與輸出都一模一樣，唯一的差別就是少了關鍵字delegate以及多了 => 符號。

Lambda expression可不只這樣。
首先我們可以知道此Lambda expression會指派給Calculator委派，該委派的方法簽章是輸入兩個int並且回傳一個int。
因此藉由型別推斷，編譯器可以知道Lambda expression的輸入與輸出的型別。
所以左方的(int a, int b)可以省略型別宣告：

Calculator calc = (a, b) => { return a+b; };

其次，因為方法主體只有一行而已，而且也只有單一動作，所以程式碼區塊的大括號{}以及return關鍵字也可以省略，編譯器會知道a+b就是回傳值。

Calculator calc = (a, b) =>  a+b;

如此，是不是比匿名方法簡潔許多呢？
唯一的缺點就是跟以往的語法相比相差比較大，初次接觸lambda expression的人會需要一段時間熟悉。


另外，如果方法的傳入參數只有一個的話，連左邊的小括號也可以省略。例如Linq的Where方法：

var list = new List {1,2,3,4,5};
var list2 = list.Where(x => x > 3);

函式傳遞的進化論 (3) - delegate

C#也是物件導向程式語言家族中的一員，因此同樣無法直接將方法傳遞給另一個方法。
C#同樣可以使用interface的技巧來包覆方法，不過這邊將介紹C#本身提供的方式:delegate(委派)
Delegate有一點像C的function pointer，其作用就是可以接收與傳遞方法。

首先使用關鍵字delegate來宣告一個delegate的類別

public delegate int Comparator(int first, int second);

這邊宣告名為Comparator的delegate類別，Comparator將會接受一種"參數是2個int並回傳1個int"的這種方法。


接著宣告一個方法可以接收Comparator類別，此方法會調用指派給委派物件的方法(有點繞口，讓我們看接下來的程式碼)

public void BubbleSort(int[] array, Comparator c)
    {
        for(var round=0; round < array.Length; round++)
        {
            for(var i=0; i<array.Length-1; i++)
            {
                if(c(array[i], array[i+1]) > 0)
                {
                    var temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                }
            }
        }
    }

在第7行時呼叫此Comparator所接收到的方法。


接下來我們要宣告符合Comparator的方法：

public int SortByAsc(int first, int second)
    {
        if(first < second)
        {
            return -1;
        }
        else if(first > second)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }

然後在呼叫bubbleSort時將此方法傳遞給Comparator物件

public static void Main()
    {
        var array = new [] {4,7,1,6,9};
        var sorter = new Sorter();
        sorter.BubbleSort(array, sorter.SortByAsc);
        
        foreach(var elem in array)
        {
            Console.WriteLine(elem);
        }
        
    }

整體完整的程式如下：

using System.IO;
using System;
 
public delegate int Comparator(int first, int second);
 
public class Sorter
{
    public static void Main()
    {
        var array = new int[] {4,7,1,6,9};
        var sorter = new Sorter();
        sorter.BubbleSort(array, sorter.SortByAsc);
        
        foreach(var elem in array)
        {
            Console.WriteLine(elem);
        }
        
    }
    
    public void BubbleSort(int[] array, Comparator c)
    {
        for(var round=0; round < array.Length; round++)
        {
            for(var i=0; i<array.Length-1; i++)
            {
                if(c(array[i], array[i+1]) > 0)
                {
                    var temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                }
            }
        }
    }
 
    public int SortByAsc(int first, int second)
    {
        if(first < second)
        {
            return -1;
        }
        else if(first > second)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
}

我們重新再看一次此程式。
首先先宣告一個委派類別Comparator(line 4)，接著宣告符合此委派類別的方法SortByAsc(line 37)。
在第12行時將SortByAsc方法傳遞給BubbleSort的第二個引數Comparator c，
而BubbleSort會在第27行時呼叫c所接收到的方法，即sorter.SortByAsc方法