From: 011netservice@gmail.com Date: 2022-04-24 Subject: Lambda.txt ---------- 20200714 這一段直接複製 SampleCode46.LambdaSample.cs 內容如下, 並確認編譯 OK: /* LambadSample.cs 20200524, Honda, 增加 ConvertAll 轉換成其他型別. 20200714, Honda, 增加 Invoke 跟 QueueUserWorkItem 的參考寫法. 20200716, Honda, Add Thread.Start. 摘要: 1. Lambda 運算子 => 意思為 goes to (移到) 例如 (x, y) => x == y; 的意思是: 將 (x, y) 2個參數移到 (x == y)的運算上. 2. 使用 Lambda Expression 並不會減損效能. 3. Lambda 運算式 (Lambda Expression)是一種匿名函式, 其實就是 delegate 的不同寫法, 描述 delegate 委派的邏輯, 可分為兩種形式: a. 一行程式碼就可以描述完成的運算式 以運算式為主體: (input-parameters) => expression 例如: A. Action line = () => Console.WriteLine(); // 描述無參數的 Action delegate. 無回傳值. A.1 ThreadPool.QueueUserWorkItem(arg => DoWork()); B. Func testForEquality = (x, y) => x == y; // 描述(回傳 bool, 傳入2個int) 的 Func delegate. 常見 4種寫法: A. (int x, string s) => s.Length > x; // 明確指定傳入參數的型別，適用在無法型別推斷的時候。 回傳 bool. B. (a, b) => a + b; // 讓編譯器使用型別推斷省去撰寫傳入參數型別的寫法。 回傳 a+b. C. a => a * a; // 只有一個傳入參數時，可以省略圓括號。 回傳 a平方. D. () => "L" + "I" + "N" + "Q"; // 沒有傳入參數時，必須用空的圓括號。 回傳 "LINQ". b. 兩行程式碼以上才能描述完成的陳述式 以陳述式為主體: (input-parameters) => { } 例如: 1. (int x, string s) => {x = x * 2; return s.Length > x;} // 回傳 bool. 2. (a, b) => {a = a + b; return a * b;} // 回傳 a*b. 3. ThreadPool.QueueUserWorkItem( arg => // Lambda 無回傳值. { DoWork(); resetEvent.Set(); }); 4. if (LblEndTime.InvokeRequired) LblEndTime.Invoke(new Action(() => { LblTime.Text = sError; })); // Lambda 無回傳值. else LblTime.Text = sError; 4. linq vs lambda linq = Language Integrated Query Visual Studio 提供(能以類似 SQL 語法查詢)的功能. 例: (較具可讀性) var _Results = from item in _List where item.Value == 1 select item; lambda = an anonymous function and is more of a like delegate type. 代表一個匿名函數, 比較像一個 delegate. 運算式中會有一個 "=>" 運算符號, 讀為 "goes to". 運算式左邊可選擇指定輸入的參數. 例: (較簡潔, 可用一行指令就完成) var _Results = _List.Where(x => x.Value == 1); 5. Lambda 是希臘字母第11個符號 (Λ, λ). lambda is the eleventh letter of the Greek alphabet (Λ, λ), transliterated as ‘l.’. ---------- 以下是常用的寫法: 常用 1: Using lambda expressions for event handlers. ref: https://stackoverflow.com/questions/2465040/using-lambda-expressions-for-event-handlers 常用語法呼叫 event handler. public partial class MyPage : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { //snip MyButton.Click += (o, i) => { //snip } } } There are no performance implications since the compiler will translate your lambda expression into an equivalent delegate. Lambda expressions are nothing more than a language feature that the compiler translates into the exact same code that you are used to working with. The compiler will convert the code you have to something like this: 編譯後, 程式會轉為相同的 delegate 執行, 不會影響效能. Lambda 語法只是 C# 語言提供的功能, 會翻譯為原本相同的 delegate 寫法. public partial class MyPage : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { //snip MyButton.Click += new EventHandler(delegate (Object o, EventArgs a) { //snip }); } } 常用2: void SampleThread() { Thread t1; Thread t2; string sResult; // .net 的寫法: t1 = new Thread(new ThreadStart(MyMethod1)); t1.Start(); t2 = new Thread(new ParameterizedThreadStart(MyMethod2)); t2.Start("Parameter"); // Lambda 的寫法: t1 = new Thread(() => { sResult = "Lambda1"; }); t1 = new Thread((state) => { sResult = state.ToString(); }); // ZLib 的寫法: t1 = ZThreading.ZStart(MyMethod1); t2 = ZThreading.ZStart(MyMethod2, "With State"); } 常用3: 在屬性回傳值時, 只要一行敘述就可以取代 Get 語法: // Lambda: public WaitHandle AsyncWaitHandle => new ManualResetEvent(true); public WaitHandle AsyncWaitHandle { get { return new ManualResetEvent(true); } } // Lambda: public bool IsCompleted => true; public bool IsCompleted { get { return true; } } 常用4: iCount = ia1.Where(p1 => p1 > 5).Count(); // 2 iSum = ia1.Where(p1 => p1 > 5).Sum(); // 16 public int CountConnected() { // 以下迴圈可用一句 Lambda 語法取代: //int iCount = 0; //foreach (ZSocketState state1 in MStates.Values) // if (state1.Connected) // iCount++; //return iCount; return MStates.Values.Where(p1 => p1.Connected).Count(); } 常用5: Invoke / BeginInvoke if (LblEndTime.InvokeRequired) LblEndTime.Invoke(new Action(() => { LblTime.Text = sError; })); // Lambda 無回傳值. else LblTime.Text = sError; ZInvokeAction(ctrl, () => ctrl.Text = sText); // CodeHelper: Lambda. /// ZInvokeAction(ctrl, () => ctrl.Text = sText); /// 或 ZInvokeAction(ctrl, () => {statement1; statement2;...}); ---------- https://stackoverflow.com/questions/6529659/wait-for-queueuserworkitem-to-complete You could use events to sync. Like this: private static ManualResetEvent resetEvent = new ManualResetEvent(false); public static void Main() { ThreadPool.QueueUserWorkItem(arg => DoWork()); resetEvent.WaitOne(); } public static void DoWork() { Thread.Sleep(5000); resetEvent.Set(); } If you don't want to embed event set into your method, you could do something like this: var resetEvent = new ManualResetEvent(false); ThreadPool.QueueUserWorkItem( arg => { DoWork(); resetEvent.Set(); }); resetEvent.WaitOne(); For multiple items: var events = new List(); foreach(var job in jobs) { var resetEvent = new ManualResetEvent(false); ThreadPool.QueueUserWorkItem( arg => { DoWork(job); resetEvent.Set(); }); events.Add(resetEvent); } WaitHandle.WaitAll(events.ToArray()); ---------- InvokeRequired, Invoke 1 InvokeRequired 原本以 delegate 的寫法較繁雜: delegate void ShowMsgCallback(string sMsg); public virtual void ShowMsg(string sMsg) { if (statusStrip1.InvokeRequired) // Sample: InvokeRequired. Invoke(new ShowMsgCallback(MyShowMsg), new Object[] { sMsg }); // Sample: Invoke() else MyShowMsg(sMsg); } void MyShowMsg(string sMsg) { lblMsg.ForeColor = ColorSaved; lblMsg.Text = sMsg; } 2 InvokeRequired 改為 Lambda 運算式寫法, 可取代 (1 delegate 的寫法), 較簡潔, 且不影響效能. private void MThread_OnError(string sType, string sError, ZThreadState State1) { if (LblEndTime.InvokeRequired) LblEndTime.Invoke(new Action(() => { LblTime.Text = sError; })); else LblTime.Text = sError; } 以 Form.Invoke 的參考樣式: private void MThread_OnStart(ZThreadState state1) { while (true) { if (InvokeRequired) { Invoke(new Action(() => { LblTime.Text = DateTime.Now.ToString(); LblEndTime.Text = MThread.EndTime.ToString(); })); } else { LblTime.Text = DateTime.Now.ToString(); LblEndTime.Text = MThread.EndTime.ToString(); } ZThreading.ZSleep(1000); } } */ using System; using System.Collections.Generic; using System.Linq; using System.Text; // add using System.Threading.Tasks; using System.Threading; namespace ZLib.DSample { class LambdaSample { event Action OnAction; event Action OnAction1Input; class cItem1 { public int _i1; public string _s1; } void LinqVsLambda1() { int iCount; int iSum; int[] ia1 = { 1, 3, 5, 7, 9 }; List list1 = new List(); list1.Add(new cItem1() { _i1 = 1, _s1 = "a" }); list1.Add(new cItem1() { _i1 = 3, _s1 = "b" }); list1.Add(new cItem1() { _i1 = 5, _s1 = "c" }); list1.Add(new cItem1() { _i1 = 7, _s1 = "a" }); list1.Add(new cItem1() { _i1 = 9, _s1 = "b" }); // linq = Language Integrated Query // Visual Studio 提供(能以類似 SQL 語法查詢)的功能. // 較具可讀性. iCount = (from p1 in ia1 where p1 > 5 select p1).Count(); // 2 iSum = (from p1 in ia1 where p1 > 5 select p1).Sum(); // 16 var vLinq1 = from p1 in list1 // _s1="a"的清單=2筆. where p1._s1 == "a" select p1; List listLinq1 = (from p1 in list1 // _s1="a"的清單=2筆. where p1._s1 == "a" select p1).ToList(); iCount = (from p1 in list1 // _s1="a"的個數=2. where p1._s1 == "a" select p1).Count(); iSum = (from p1 in list1 // sum((_s1="a"的項目).i1) = 8. where p1._s1 == "a" select p1._i1).Sum(); // lambda = an anonymous function and is more of a like delegate type. // 代表一個匿名函數, 比較像一個 delegate. // 運算式中有一個 "=>" 運算符號, 讀為 "goes to". // 運算式左邊為輸入的參數. // 較簡潔, 可用一行指令就完成. iCount = ia1.Where(p1 => p1 > 5).Count(); // 2 iSum = ia1.Where(p1 => p1 > 5).Sum(); // 16 var vLambda1 = list1.Where(p1 => p1._s1 == "a"); // _s1="a"的清單=2筆. List listLambda1 = list1.Where(p1 => p1._s1 == "a").ToList(); // _s1 = "a"的清單 = 2筆. // 轉成其他型別 List listia1 = ia1.Where(p1 => p1 > 5).ToList(); List listda1 = listia1.ConvertAll(IntToDouble); } double IntToDouble(int iInput) { return iInput; } void SampleThread() { Thread t1; Thread t2; string sResult; // .net 的寫法: t1 = new Thread(new ThreadStart(MyMethod1)); t1.Start(); t2 = new Thread(new ParameterizedThreadStart(MyMethod2)); t2.Start("Parameter"); // Lambda 的寫法: t1 = new Thread(() => { sResult = "Lambda1"; }); t1.Start(); t2 = new Thread((state) => { sResult = state.ToString(); }); t2.Start(); ThreadPool.QueueUserWorkItem(arg => MyMethod1()); ThreadPool.QueueUserWorkItem(arg => { MyMethod1(); }); ThreadPool.QueueUserWorkItem(arg => MyMethod2(arg)); ThreadPool.QueueUserWorkItem(arg => { MyMethod2(arg); }); // ZLib 的寫法: t1 = ZThreading.ZStart(MyMethod1); t2 = ZThreading.ZStart(MyMethod2, "With State"); } void MyMethod1() { Console.WriteLine($"MyMethod1(), ThreadID={ZThreading.ZGetCurrentThreadID()}"); } void MyMethod2(object State) { Console.WriteLine($"MyMethod2(), {State.ToString()}, ThreadID={ZThreading.ZGetCurrentThreadID()}"); } void SampleWhere1() { // form o in SomeList where o.Col1 == "A" && o.Col2 == "B" select o int[] ia1 = { 1, 3, 5, 7, 9 }; int iCount = (from number in ia1 where number > 5 select number).Count(); // 2 int iSum = (from number in ia1 where number > 5 select number).Sum(); // 16 } void SampleFunc2String() { // Declare a Func variable and assign a lambda expression to the // variable. The method takes a string and converts it to uppercase. Func selector = str => str.ToUpper(); // Create an array of strings. string[] words = { "orange", "apple", "Article", "elephant" }; // Query the array and select strings according to the selector method. IEnumerable aWords = words.Select(selector); // Output the results to the console. foreach (String word in aWords) Console.WriteLine(word); /* This code example produces the following output: ORANGE APPLE ARTICLE ELEPHANT */ } async Task AsyncTask2(string sInput) { // 呼叫一個 Task.Run(Action) await Task.Run(() => myBlockingMethod(sInput)); } async Task AsyncTask3(string sInput) { // 呼叫一個 Task.Run(Action)傳入一個物件參數! 不是字串參數, 字串會轉為object傳入 Task.Run. return await Task.Run(() => { return myBlockingMethod(sInput); }); } void StartByLambda2() { OnAction += async () => await myOnStartTask(); } Task StartByLambda3() { Task t1 = null; OnAction += async () => await (t1 = myOnStartTask()); return t1; } Task asyncByLambda4(string sInput) { Task t1 = null; OnAction1Input += async (p1) => await (t1 = myBlockingTask(p1)); //OnAction1Input += async (p1) => await (Task < string > t1 = myBlockingTask(p1)); return t1; } string myBlockingMethod(string sInput) { ZThreading.ZSleep(2000); return "myBlockingMethod()+" + sInput; } Task myOnStartTask() { Task t1 = Task.Run(() => { myOnStart(); }); return t1; } private void myOnStart() { if (OnAction != null) OnAction(); if (OnAction1Input != null) OnAction1Input("解除warning"); } private Task myBlockingTask(string sInput) { Task t1 = Task.Run(() => { return myBlockingMethod(sInput); }); return t1; } } } ---------- 20191001 https://docs.microsoft.com/zh-tw/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions https://docs.microsoft.com/zh-tw/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions lambda is the eleventh letter of the Greek alphabet (Λ, λ), transliterated as ‘l.’. ---------- 20190808 int[] ia1 = { 1, 3, 5, 7, 9 }; int iCount = (from number in ia1 where number > 5 select number).Count(); // 2 int iSum = (from number in ia1 where number > 5 select number).Sum(); // 16 ---------- 20190123 ref: https://jax-work-archive.blogspot.com/2014/02/c-sharp-delegate-to-lambda-expressions-syntax-transform.html 一開始要看懂 Lambda Expressions 有點困難，下面會以演進方式來介紹如何做到語法省略。 首先定義一個單參數的 delegate delegate int Del(int x); 以傳統 delegate 的語法來建構 delegate Del a = delegate(int x) { return x + 2; }; 去掉 delegate 改成 Lambda 表示式 Del a = (int x) => { return x + 2; }; 由於大括號裡只有一句陳述式，而且是一個 return 的陳述式,所以可以省略大括號跟 return Del a = (int x) => x + 2; 在 delegate 已經有定義輸入參數的型別，所以在小括號裡的型別可以省略 Del a = (x) => x + 2; 由於小括號裡面只有一個輸入參數，所以可以再進一步省略小括號 Del a = x => x + 2; 使用例: int? a = (new List{2}).Select(x => x).FirstOrDefault(); // 2 int? b = (new List{}).Select(x => x).FirstOrDefault(); // 0 int? c = (new List{2}).Select(x => (int?)x).FirstOrDefault(); // 2 int? d = (new List{}).Select(x => (int?)x).FirstOrDefault(); // null ---------- 20190123 ref: https://docs.microsoft.com/zh-tw/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions Lambda 運算式是 匿名函式 ，可用來建立 委派 或 運算式樹狀架構 類型 使用 Lambda 運算式可以撰寫區域函式，這些函式可以當做引數傳遞，或是當做函式呼叫的值傳回。 Lambda 運算式對於撰寫 LINQ 查詢運算式而言特別有用。 (input-parameters) => expression 兩個或多個輸入參數會包含在括號中，並且以逗號分隔: (x, y) => x == y 指定類型: (int x, string s) => s.Length > x 以空括號指定零個輸入參數: () => SomeMethod() 陳述式 Lambda 看起來就像是運算式 Lambda，不同之處在於，陳述式會包含於大括號內： (input-parameters) => { statement; } 陳述式 Lambda 的主體可以包含任意數目的陳述式，但是實際上通常不會超過兩個或三個陳述式。 delegate void TestDelegate(string s); TestDelegate del = n => { string s = n + " World"; Console.WriteLine(s); }; ---------- Lambda Expression 匿名方法的簡潔寫法 ref: https://jeffprogrammer.wordpress.com/2016/01/02/觀念-lambda-expression-func/ Lambda Expression 是傳統匿名方法的簡潔寫法，許多高階程式語言都支援，例如 Java 、 C++ 、 C# 等。 C# Lambda Expression 使用 「 => 」 做為運算符號，讀法很多種，像是 「such that」、「maps to」、「lambda」、「goes to 」。 語法如下所示： ( 參數 ) => { 運算式 } 這語法做的事是：把左邊的參數丟到右邊的運算式去做運算。 Lambda Expression 經常用在委派 ( delegate ) 。 我們看下面的例子。 上圖程式的 list.FindAll( )需要輸入的參數是委派方法 Predicate。 傳統寫法是自己去定義一個方法來被委派。 較簡單的寫法是匿名，如上圖的這段： delegate(int i) { return (i % 2) == 0; } Lambda Expression 提供一個更簡潔的寫法： i => ( i % 2 ) == 0 ---------- 20181221 原本的 Func 匿名方法委派方式: using System; public class Anonymous { public static void Main() { Func convert = delegate(string s) { return s.ToUpper();}; string name = "Dakota"; Console.WriteLine(convert(name)); } } 相同的Func 改用 Lambda運算式委派Func: using System; public class LambdaExpression { public static void Main() { Func convert = s => s.ToUpper(); string name = "Dakota"; Console.WriteLine(convert(name)); } } ---------- 20181109 以下兩者意義相同: 1. timer.Elapsed += async ( sender, e ) => await HandleTimer(); private Task HandleTimer() { Console.WriteLine("\nHandler not implemented..." ); return Task.FromResult(null); } 2. timer.Elapsed = CallHandleTimer; async void CallHandleTimer(object sender, EventArgs e) { await HandleTimer(); } 以下兩者意義相同: 1. using System; using System.Threading; using System.Threading.Tasks; public class Example { public static void Main() { ShowThreadInfo("Application"); var t = Task.Run(() => ShowThreadInfo("Task") ); t.Wait(); } static void ShowThreadInfo(String s) { Console.WriteLine("{0} Thread ID: {1}", s, Thread.CurrentThread.ManagedThreadId); } } // The example displays the following output: // Application thread ID: 1 // Task thread ID: 3 2. using System; using System.Threading; using System.Threading.Tasks; public class Example { public static void Main() { Console.WriteLine("Application thread ID: {0}", Thread.CurrentThread.ManagedThreadId); var t = Task.Run(() => { Console.WriteLine("Task thread ID: {0}", Thread.CurrentThread.ManagedThreadId); } ); t.Wait(); } } // The example displays the following output: // Application thread ID: 1 // Task thread ID: 3 ---------- 20180928 Lambda Expressions ref: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions https://docs.microsoft.com/zh-tw/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions In this article Expression Lambdas Statement Lambdas Async Lambdas Lambdas with the Standard Query Operators Type Inference in Lambdas Variable Scope in Lambda Expressions C# Language Specification Featured Book Chapter See Also A lambda expression is an anonymous function that you can use to create delegates or expression tree types. By using lambda expressions, you can write local functions that can be passed as arguments or returned as the value of function calls. Lambda expressions are particularly helpful for writing LINQ query expressions. To create a lambda expression, you specify input parameters (if any) on the left side of the lambda operator =>, and you put the expression or statement block on the other side. For example, the lambda expression x => x * x specifies a parameter that’s named x and returns the value of x squared. You can assign this expression to a delegate type, as the following example shows: 原先使用 delegate 的語法, 可利用 lambda expression 簡化語法如下: delegate int del(int i); static void Main(string[] args) { del myDelegate = x => x * x; int j = myDelegate(5); //j = 25 } To create an expression tree type: using System.Linq.Expressions; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Expression myET = x => x * x; } } } The => operator has the same precedence as assignment (=) and is right associative (see "Associativity" section of the Operators article). Lambdas are used in method-based LINQ queries as arguments to standard query operator methods such as Where. When you use method-based syntax to call the Where method in the Enumerable class (as you do in LINQ to Objects and LINQ to XML) the parameter is a delegate type System.Func. A lambda expression is the most convenient way to create that delegate. When you call the same method in, for example, the System.Linq.Queryable class (as you do in LINQ to SQL) then the parameter type is an System.Linq.Expressions.Expression where Func is any of the Func delegates with up to sixteen input parameters. Again, a lambda expression is just a very concise way to construct that expression tree. The lambdas allow the Where calls to look similar although in fact the type of object created from the lambda is different. In the previous example, notice that the delegate signature has one implicitly-typed input parameter of type int, and returns an int. The lambda expression can be converted to a delegate of that type because it also has one input parameter (x) and a return value that the compiler can implicitly convert to type int. (Type inference is discussed in more detail in the following sections.) When the delegate is invoked by using an input parameter of 5, it returns a result of 25. Lambdas are not allowed on the left side of the is or as operator. All restrictions that apply to anonymous methods also apply to lambda expressions. For more information, see Anonymous Methods. ---------- Expression Lambdas A lambda expression with an expression on the right side of the => operator is called an expression lambda. Expression lambdas are used extensively in the construction of Expression Trees. An expression lambda returns the result of the expression and takes the following basic form: (input-parameters) => expression The parentheses are optional only if the lambda has one input parameter; otherwise they are required. Two or more input parameters are separated by commas enclosed in parentheses: (x, y) => x == y Sometimes it is difficult or impossible for the compiler to infer the input types. When this occurs, you can specify the types explicitly as shown in the following example: (int x, string s) => s.Length > x Input paramater types must be all explicit or all implicit; otherwise, C# generates a CS0748 compiler error. Specify zero input parameters with empty parentheses: () => SomeMethod() Note in the previous example that the body of an expression lambda can consist of a method call. However, if you are creating expression trees that are evaluated outside of the .NET Framework, such as in SQL Server, you should not use method calls in lambda expressions. The methods will have no meaning outside the context of the .NET common language runtime. ---------- Statement Lambdas A statement lambda resembles an expression lambda except that the statement(s) is enclosed in braces: (input-parameters) => { statement; } The body of a statement lambda can consist of any number of statements; however, in practice there are typically no more than two or three. delegate void TestDelegate(string s); TestDelegate del = n => { string s = n + " World"; Console.WriteLine(s); }; Statement lambdas, like anonymous methods, cannot be used to create expression trees. ---------- Async Lambdas You can easily create lambda expressions and statements that incorporate asynchronous processing by using the async and await keywords. For example, the following Windows Forms example contains an event handler that calls and awaits an async method, ExampleMethodAsync. public partial class Form1 : Form { public Form1() { InitializeComponent(); } private async void button1_Click(object sender, EventArgs e) { // ExampleMethodAsync returns a Task. await ExampleMethodAsync(); textBox1.Text += "\r\nControl returned to Click event handler.\n"; } async Task ExampleMethodAsync() { // The following line simulates a task-returning asynchronous process. await Task.Delay(1000); } } You can add the same event handler by using an async lambda. To add this handler, add an async modifier before the lambda parameter list, as the following example shows. public partial class Form1 : Form { public Form1() { InitializeComponent(); button1.Click += async (sender, e) => { // ExampleMethodAsync returns a Task. await ExampleMethodAsync(); textBox1.Text += "\nControl returned to Click event handler.\n"; }; } async Task ExampleMethodAsync() { // The following line simulates a task-returning asynchronous process. await Task.Delay(1000); } } For more information about how to create and use async methods, see Asynchronous Programming with async and await. ---------- Lambdas with the Standard Query Operators Many Standard query operators have an input parameter whose type is one of the Func family of generic delegates. These delegates use type parameters to define the number and types of input parameters, and the return type of the delegate. Func delegates are very useful for encapsulating user-defined expressions that are applied to each element in a set of source data. For example, consider the following delegate type: public delegate TResult Func(TArg0 arg0) The delegate can be instantiated as Func myFunc where int is an input parameter and bool is the return value. The return value is always specified in the last type parameter. Func defines a delegate with two input parameters, int and string, and a return type of bool. The following Func delegate, when it is invoked, will return true or false to indicate whether the input parameter is equal to 5: Func myFunc = x => x == 5; bool result = myFunc(4); // returns false of course You can also supply a lambda expression when the argument type is an Expression, for example in the standard query operators that are defined in System.Linq.Queryable. When you specify an Expression argument, the lambda will be compiled to an expression tree. A standard query operator, the Count method, is shown here: int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; int oddNumbers = numbers.Count(n => n % 2 == 1); The compiler can infer the type of the input parameter, or you can also specify it explicitly. This particular lambda expression counts those integers (n) which when divided by two have a remainder of 1. The following line of code produces a sequence that contains all elements in the numbers array that are to the left side of the 9 because that's the first number in the sequence that doesn't meet the condition: var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6); This example shows how to specify multiple input parameters by enclosing them in parentheses. The method returns all the elements in the numbers array until a number is encountered whose value is less than its position. Do not confuse the lambda operator (=>) with the greater than or equal operator (>=). var firstSmallNumbers = numbers.TakeWhile((n, index) => n >= index); ---------- Type Inference in Lambdas When writing lambdas, you often do not have to specify a type for the input parameters because the compiler can infer the type based on the lambda body, the parameter’s delegate type, and other factors as described in the C# Language Specification. For most of the standard query operators, the first input is the type of the elements in the source sequence. So if you are querying an IEnumerable, then the input variable is inferred to be a Customer object, which means you have access to its methods and properties: customers.Where(c => c.City == "London"); The general rules for lambdas are as follows: 1. The lambda must contain the same number of parameters as the delegate type. 2. Each input parameter in the lambda must be implicitly convertible to its corresponding delegate parameter. 3. The return value of the lambda (if any) must be implicitly convertible to the delegate's return type. Note that lambda expressions in themselves do not have a type because the common type system has no intrinsic concept of "lambda expression." However, it is sometimes convenient to speak informally of the "type" of a lambda expression. In these cases the type refers to the delegate type or Expression type to which the lambda expression is converted. ---------- Variable Scope in Lambda Expressions Lambdas can refer to outer variables (see Anonymous Methods) that are in scope in the method that defines the lambda function, or in scope in the type that contains the lambda expression. Variables that are captured in this manner are stored for use in the lambda expression even if the variables would otherwise go out of scope and be garbage collected. An outer variable must be definitely assigned before it can be consumed in a lambda expression. The following example demonstrates these rules: delegate bool D(); delegate bool D2(int i); class Test { D del; D2 del2; public void TestMethod(int input) { int j = 0; // Initialize the delegates with lambda expressions. // Note access to 2 outer variables. // del will be invoked within this method. del = () => { j = 10; return j > input; }; // del2 will be invoked after TestMethod goes out of scope. del2 = (x) => {return x == j; }; // Demonstrate value of j: // Output: j = 0 // The delegate has not been invoked yet. Console.WriteLine("j = {0}", j); // Invoke the delegate. bool boolResult = del(); // Output: j = 10 b = True Console.WriteLine("j = {0}. b = {1}", j, boolResult); } static void Main() { Test test = new Test(); test.TestMethod(5); // Prove that del2 still has a copy of // local variable j from TestMethod. bool result = test.del2(10); // Output: True Console.WriteLine(result); Console.ReadKey(); } } The following rules apply to variable scope in lambda expressions: 1. A variable that is captured will not be garbage-collected until the delegate that references it becomes eligible for garbage collection. 2. Variables introduced within a lambda expression are not visible in the outer method. 3. A lambda expression cannot directly capture an in, ref, or out parameter from an enclosing method. 4. A return statement in a lambda expression does not cause the enclosing method to return. 5. A lambda expression cannot contain a goto statement, break statement, or continue statement that is inside the lambda function if the jump statement’s target is outside the block. It is also an error to have a jump statement outside the lambda function block if the target is inside the block. ---------- 20160228 before 「Lambda 運算式」(Lambda Expression) 是一種匿名函式，它可以包含運算式和陳述式 (Statement)，而且可以用來建立委派 (Delegate) 或運算式樹狀架構型別。 所有的 Lambda 運算式都會使用 Lambda 運算子 =>，意思為「移至」。Lambda 運算子的左邊會指定輸入參數 (如果存在)，右邊則包含運算式或陳述式區塊。Lambda 運算式 x => x * x 的意思是「x 移至 x 乘以 x」。這個運算式可以指派成委派型別 (Delegate Type)，如下所示： delegate int del(int i); del myDelegate = x => x * x; int j = myDelegate(5); //j = 25 ---------- using System; using System.Linq; public class CSharpLab { //宣告一個delegate, 自訂a, b二數運算的邏輯 delegate int myLogic(int a, int b); public static void Test() { int x=3, y=5; //原本的標準delegate寫法, 要額外宣告一個Method calc(x, y, new myLogic(addMethod)); //省事一點的匿名寫法 calc(x, y, delegate(int a, int b) { return a+b; }); //再省下去，就來段黏巴達(Lambada)Lambda吧 calc(x, y, (a,b)=>a+b); calc(x, y, (a,b)=>a-b); calc(x, y, (a,b)=>a*b); } static void calc(int x, int y, myLogic cc) { Console.WriteLine(cc(x, y)); } static int addMethod(int a, int b) { return a+b; } } ---------- ---------- 20200524 以下從原本的 LINQ.txt 複製過來: ---------- 20190811 linq vs lambda linq = Language Integrated Query Visual Studio 提供(能以類似 SQL 語法查詢)的功能. 例: (較具可讀性) var _Results = from item in _List where item.Value == 1 select item; lambda = an anonymous function and is more of a like delegate type. 代表一個匿名函數, 比較像一個 delegate. 運算式中會有一個 "=>" 運算符號, 讀為 "goes to". 運算式左邊可選擇指定輸入的參數. 例: (較簡潔, 可用一行指令就完成) var _Results = _List.Where(x => x.Value == 1); ---------- 20190526 參考 LINQ.txt ref: https://ithelp.ithome.com.tw/articles/10104439 LINQ自學筆記-語法應用-單項資料-First、Last、ElementAt、Single 本文將為大家介紹 LINQ 取得資料來源中單一項目的運算子：First、Last、ElementAt、Single，以及相匹配的 FirstOrDefault、LastOrDefault、ElementAtOrDefault、SingleOrDefault 運算子。 自學筆記這系列是我自己學習的一些心得分享，歡迎指教。這系列的分享，會以 C# + 我比較熟的 Net 3.5 環境為主。 另外本系列預計至少會切成【打地基】和【語法應用】兩大部分做分享。打地基的部分，講的是 LINQ 的組成元素，這部分幾乎和 LINQ 無關，反而是 C# 2.0、C# 3.0 的一堆語言特性，例如：型別推斷、擴充方法、泛型、委派等等，不過都會把分享的範圍限制在和 LINQ 應用有直接相關功能。 PS. LINQ 自學筆記幾乎所有範例，都可直接複製到 LINQPad 4 上執行（大多是用 Statements 和 Program 模式）。因為它輕巧好用，功能強大，寫範例很方便，請大家自行到以下網址下載最新的 LINQPad：http://www.LINQpad.net/。 在 LINQ 技術中，有設計一組專門用來取出來源序列中單一項目的運算子，也就是 First、Last、ElementAt、Single，它們同時也都搭配了一組取不到資料就輸出來源資料型別預設值的運算子：FirstOrDefault、LastOrDefault、ElementAtOrDefault、SingleOrDefault，這些就是本文的主題。 請注意，這八個標準查詢運算子都不支援查詢語法（Query syntax），必須用方法語法（Method syntax）才能使用，而且這八個運算子都是立即執行（Immediately execution）查詢的運算子，使用時請留心。 最常用、最通用的就是 First、FirstOrDefault 運算子，它們會回傳來源序列中的第一個元素，或符合條件的第一個元素。它們都有兩個多載方法： public static TSource First( this IEnumerable source ) public static TSource First( this IEnumerable source, Func predicate ) public static TSource FirstOrDefault( this IEnumerable source ) public static TSource FirstOrDefault( this IEnumerable source, Func predicate ) 兩個運算子的第一個方法都不用傳入參數，都是 IEnumerable 的擴充方法，可以直接呼叫；第二個擴充方法則是支援我們傳入一個委派方法（Func predicate），自行定義要取出符合怎樣條件的第一筆資料。 先談談 First 和 FirstOrDefault 的差別是什麼：First 運算子，若取不到資料，會在執行時期拋出 InvalidOperationException 例外，但是 FirstOrDefault 則會回傳 TSource 的預設值。這個差別可以同時套用在 Last、ElementAt、Single、LastOrDefault、ElementAtOrDefault、SingleOrDefault 運算子身上，後續就不再特別說明此差異。 我們先看呼叫第一個多載方法的範例： void Main() { //建立訂單資料來源 var orders = new List(){ new Order {CustomerId = 3, OrderDate = new DateTime(2011, 10, 9), Total = 2940}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 10, 10), Total = 3849}, new Order {CustomerId = 1, OrderDate = new DateTime(2011, 12, 1), Total = 500}, new Order {CustomerId = 1, OrderDate = new DateTime(2012, 2, 28), Total = 1234}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 5, 20), Total = 9520} }; var queryFirst = orders.First(); queryFirst.Dump("First"); //orders 中沒有顧客編號 4 的資料，用 First 會出現錯誤，所以要用 FirstOrDefault var queryFD = orders.Where(o => o.CustomerId == 4).FirstOrDefault(); queryFD.Dump("FirstOrDefault"); } //訂單基本資料類別 public class Order { public int CustomerId { get; set; } public DateTime OrderDate { get; set; } public double Total { get; set; } public override string ToString() { return string.Format("CustomerId = {0}, OrderDate = {1}, Total = {2}", CustomerId, OrderDate, Total); } } 上述程式碼，我們建立一個序列儲存訂單資料（orders），然後定義第一個查詢（queryFirst），直接取出第一筆訂單資料，因為沒有做排序，所以 First 運算子抓到的是第一個加入清單中的訂單資料。接著我們再定義第二個查詢（queryFD），先用 Where 運算子篩選出顧客編號（CustomerId） 4 的訂單資料，再用 FirstOrDefault 運算子取出第一筆資料，但實際上訂單資料中沒有顧客編號 4 的資料，所以查詢結果會回傳 null。此處若是改用 First 運算子，則會出現 InvalidOperationException 錯誤。 再來看呼叫第二個多載方法的範例，請注意，我們直接沿用上述的範例程式碼，所以不再貼出 Order 類別，比較不注浪費篇幅： void Main() { //建立訂單資料來源 var orders = new List(){ new Order {CustomerId = 3, OrderDate = new DateTime(2011, 10, 9), Total = 2940}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 10, 10), Total = 3849}, new Order {CustomerId = 1, OrderDate = new DateTime(2011, 12, 1), Total = 500}, new Order {CustomerId = 1, OrderDate = new DateTime(2012, 2, 28), Total = 1234}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 5, 20), Total = 9520} }; var queryFirst2 = orders.First(o => o.Total < 2000); queryFirst2.Dump("First 第二個多載方法"); var queryFD2 = orders.FirstOrDefault(o => o.CustomerId == 4); queryFD2.Dump("FirstOrDefault 第二個多載方法"); } 上述程式碼，我們定義第一個查詢（queryFirst2），直接在訂單資料（orders）上調用 First 運算子，但是我們傳入一個 Lambda 運算式，設定篩選出訂單金額（Total）小於 2000 元的資料，因為沒有指定排序，所以 First 運算子會取出符合條件的第一筆資料，也就是上述畫面的第一個表格內容。接著我們定義第二個查詢（queryFD2），直接在訂單資料上調用 FirstOrDefault 運算子，並傳入一個 Lambda 運算式，設定篩選出顧客編號 4 的訂單資料，因為沒有此顧客的訂單資料，所以會回傳預設值，也就是 null。 Last、LastOrDefault 運算子和 First、FirstOrDefault 用法完全相同，只是這組運算子是取來源序的最後一筆資料。請注意，Last、LastOrDefault 運算子不支援 LINQ to Entities 和 LINQ to SQL。 public static TSource Last( this IEnumerable source ) public static TSource Last( this IEnumerable source, Func predicate ) public static TSource LastOrDefault( this IEnumerable source ) public static TSource LastOrDefault( this IEnumerable source, Func predicate ) void Main() { //建立訂單資料來源 - LINQ to Objects var orders = new List(){ new Order {CustomerId = 3, OrderDate = new DateTime(2011, 10, 9), Total = 2940}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 10, 10), Total = 3849}, new Order {CustomerId = 1, OrderDate = new DateTime(2011, 12, 1), Total = 500}, new Order {CustomerId = 1, OrderDate = new DateTime(2012, 2, 28), Total = 1234}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 5, 20), Total = 9520} }; var queryLast = orders.Last(); queryLast.Dump("Last"); var queryLD = orders.Where(o => o.CustomerId == 4).LastOrDefault(); queryLD.Dump("LastOrDefault"); var queryLast2 = orders.Last(o => o.Total < 2000); queryLast2.Dump("Last 第二個多載方法"); var queryLD2 = orders.LastOrDefault(o => o.CustomerId == 4); queryLD2.Dump("LastOrDefault 第二個多載方法"); //建立訂單資料來源 - LINQ to Entities // var OrderEntities = from o in Orders where o.Freight > 700 select new {o.CustomerID, o.OrderID, o.Freight, o.ShipCountry}; // OrderEntities.Last(); } //訂單基本資料類別 public class Order { public int CustomerId { get; set; } public DateTime OrderDate { get; set; } public double Total { get; set; } public override string ToString() { return string.Format("CustomerId = {0}, OrderDate = {1}, Total = {2}", CustomerId, OrderDate, Total); } } 上述程式碼，我用沿用先前 First 運算子的程式碼，只是改成 Last 運算子，大家可以比較一下輸出結果。另外程式面中有兩行註解掉的程式碼： // var OrderEntities = from o in Orders where o.Freight > 700 select new {o.CustomerID, o.OrderID, o.Freight, o.ShipCountry}; // OrderEntities.Last(); [code] 其實就是在建立 LINQ to Entities 的資料來源，並在來源上調用 Last 運算子，但是執行時會發生 NotSupportedException 例外。 第三個主題是 ElementAt 和 ElementAtOrDefault 運算子。請注意，ElementAt、ElementAtOrDefault 運算子不支援 LINQ to Entities 和 LINQ to SQL。 [code] public static TSource ElementAt( this IEnumerable source, int index ) public static TSource ElementAtOrDefault( this IEnumerable source, int index ) 這兩個運算子都只有一個簽名碼，也就是傳入一個 int 型別的參數，告訴 LINQ 我們要取的是來源序列中，第幾個索引值的項目。同樣的，若索引值不存在，ElementAt 會拋出例外，ElementAtOrDefault 會回傳 TSource 預設值： void Main() { //建立訂單資料來源 - LINQ to Objects var orders = new List(){ new Order {CustomerId = 3, OrderDate = new DateTime(2011, 10, 9), Total = 2940}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 10, 10), Total = 3849}, new Order {CustomerId = 1, OrderDate = new DateTime(2011, 12, 1), Total = 500}, new Order {CustomerId = 1, OrderDate = new DateTime(2012, 2, 28), Total = 1234}, new Order {CustomerId = 2, OrderDate = new DateTime(2012, 5, 20), Total = 9520} }; var queryElemantAt = orders.ElementAt(1); queryElemantAt.Dump("ElemantAt"); var queryElemantAtD = orders.Where(o => o.CustomerId == 4).ElementAtOrDefault(1); queryElemantAtD.Dump("ElemantAtOrDefault"); } //訂單基本資料類別 public class Order { public int CustomerId { get; set; } public DateTime OrderDate { get; set; } public double Total { get; set; } public override string ToString() { return string.Format("CustomerId = {0}, OrderDate = {1}, Total = {2}", CustomerId, OrderDate, Total); } } 上述程式碼，第一個查詢使用 ElementAt 運算子，指定要取出索引值為 1 的項目，輸出結果如上圖第一個表格內容；第二個查詢使用 ElementAtOrDefault 運算子，對一個空的資料來源指定要取出索引值為 1 的項目，結果回傳 null。 最後是 Single、SingleOrDefault 運算子。這兩個運算子有幾個特性要注意： .Net 3.5 的 LINQ to Entities、LINQ to SQL 都不支援，但是 .Net 4.0 以上就支援了。 Single 運算子，若資料來源為空值，會拋出 ArgumentNullException 例外；若資料來源包含多個項目，會拋出 InvalidOperationException 例外。換言之，要正確取出結果，來源序列必須只有一筆資料。 SingleOrDefault 運算子，若資料來源為空值，則會輸出 TSource 型別預設值；若資料來源包含多個項目，會拋出 InvalidOperationException 例外。 public static TSource FirstOrDefault( this IEnumerable source ) public static TSource FirstOrDefault( this IEnumerable source, Func predicate ) 0 public static TSource FirstOrDefault( this IEnumerable source ) public static TSource FirstOrDefault( this IEnumerable source, Func predicate ) 1 public static TSource FirstOrDefault( this IEnumerable source ) public static TSource FirstOrDefault( this IEnumerable source, Func predicate ) 2 上述程式碼，第一和第三個查詢（querySingle、querySingle2），差別只是把過濾來源序列成為單筆資料的條件是放在 Where 運算子，或是在 Single 第二個多載方法中；同樣地，第二、四個查詢也只是把篩選條件放在 Where 運算子或 SingleOrDefault 運算子中而已。