C#筆記 – 委托

委托與Lambda表達式

• 表達式的類型并非委托類型，但它可以通過隱式/顯式轉換成一個委托實例

• 匿名函數 = 匿名方法 + Lambda表達式

  • 兩者在很多情況下可以使用相同的轉換規則

• Func<T1-16, TResult>

  • T1-16：可獲16的類型參數

  • TResult：返回類型參數

• 使用 => 操作符，告訴編譯器我們正使用一個Lambda表達式

  • Func<string, int> returnLength;
    returnLength = (string text) => { return text.Length; }
    
    //單一表達式作為主體
    //該表達式的值是Lambda的結果
    //只指定表達式，不使用大括號，不使用return語句，也不添加分號
    returnLength = (string text) => text.Length;
    
    //隱式類型的參數列表
    //由編譯器去推斷，不需要顯式聲明（整個列表就是顯式/隱式）
    //如果有out/ref參數，就必須使用顯式類型
    returnLength = (text) => text.Length;
    
    //單一參數
    //如果只需要一個參數，可以省略括號
    returnLength = text => text.Length;

• 高階（High-order）函數

  • Lambda表達式的主體本身包含另一個Lambda表達式

  • Lambda表達式的參數是另一個委托

  • 如：List的過濾/排序/操作

//C# Code
public class Film
{
    public string Name { get; set; }
    public int Year { get; set; }
}

static void Main()
{
    var films = new List<Film>
    {
        new Film{ Name = "The Wizard of Oz", Year = 1939 },
        new Film{ Name = "Jaws", Year = 1975 },
        new Film{ Name = "Singing in the Rain", Year = 1952 },
    };
    Action<Film> print = film => Console.WriteLine($"Name={film.Name}, Year={film.Year}");
    films.ForEach(print);
    films.FindAll(film => film.Year < 1960).ForEach(print);
    films.Sort((f1, f2) => f1.Name.CompareTo(f2.Name));
    films.ForEach(print);    
}

• 編譯器看到lambda表達式，會自動為其創建一個匿名函數和委托類型變量

  • static void Main(string[] args)
    {
        LambdaTest(obj => Console.WriteLine(obj), 50);
    }
    public static void LambdaTest(TestDelegate d, int n)
    {
        d?.Invoke(n);
    }

  • 方法名字的生成不是固定的，本次生成為”<>c”

  • 委托類型變量名字的生成也不是固定的，本次生成為”<>9__0_0″

• 代碼大概會被編譯成這個樣子

  • [CompilerGenerated]
    private static TestDelegate <>9__0_0; //自動生成的委托類型名
        
    static void Main(string[] args)
    {
        if(<>9__0_0 == null)
        {
            <>9__0_0 = new TestDelegate(<Main>b__0_0)
        }
        LambdaTest(<>9__0_0, 50);
    }
    
    [CompilerGenerated]
    private static void <Main>b__0_0(Object obj)
    {
        Console.WriteLine(obj);
    }

• 另外，如果Lambda表達式中使用到了一些局部變量的話，C#也會為我們完成一些複雜的過程

  • int n = 50;
    static void Main(string[] args)
    {
        LambdaTest(obj => Console.WriteLine(obj), n);
    }

  • C#會定義一個輔助類

    • 該類為打算傳給回調代碼的每個值都定義一個字段

    • 回調代碼會定義成輔助類中的實例方法

    • 構造輔助類的實例，用局部變量的值來初始化輔助類裡的字段

    • 最後構造綁定到輔助對象/實例的委托對象

    • 示例：

//Origin CSharp
internal sealed class AClass
{
    public static void UsingLocalVariableInTheCallbackCode(int numToDo)
    {
        int[] squares = new int[numToDo];
        AutoResetEvent done = new AutoResetEvent(false);

        for (int n = 0; n < squares.Length; n++)
        {
            ThreadPool.QueueUserWorkItem(
                obj => {
                    int num = (int)obj;
                    squares[num] = num * num;
                    if(Interlocked.Decrement(ref numToDo) == 0)
                    {
                        done.Set();
                    }
                }, n);                    
        }

        done.WaitOne();
  
        for (int n = 0; n < squares.Length; n++)
        {
            Console.WriteLine($"Index :{n}, Square={squares[n]}");
        }
    }        
}

//Rewrite By CSharp
internal sealed class AClass
{
    public static void UsingLocalVariableInTheCallbackCode(int numToDo)
    {
        //Auto Added
        WaitCallback callback1 = null;
        
        //Support Class Instance
        <>c_DisplayClass2 class1 = new <>c_DisplayClass2();
        
        //Init Support class fields
        class1.numToDo = numToDo;
        class1.squares = new int[class1.numToDo];
        class1.done = new AutoResetEvent(false);
        
        for(int n = 0; n < class1.squares.Length; n++)
        {
            if(callback1 == null)
            {
                //新建的委托對象綁定到輔助對象及其匿名實例方法
                callback1 = new WaitCallback(
                    class1.<UsingLocalVariablesInTheCallbackCode>b__0);
            }
            
            ThreadPool.QueueUserWorkItem(callback1, n);
        }

        class1.done.WaitOne();

        for (int n = 0; n < class1.squares.Length; n++)
        {
            Console.WriteLine($"Index :{n}, Square={class1.squares[n]}");
        }
    }        
}

//Support Class
[CompileGenerated]
private sealed class <>c_DisplayClass2:Object{
    public int[] squares;
    public int numToDo;
    public AutoResetEvent done;
    
    public <>c_DisplayClass2 { }
    
    public void <UsingLocalVariablesInTheCallbackCode>b__0(Object obj)
    {
        int num = (int)obj;
        squares[num] = num * num;
        if(Interlocked.Decrement(ref numToDo) == 0)
        {
            done.Set;
        }
    }
}