Understanding LINQ and Lambda Expressions in C#

• LINQ's fundamental building block is the ability to create pipelines of operations, along with any state required by those operations.
• Operations express logic relating to filtering, ordering, and joining data sources.
• When LINQ queries are executed in-process, the operations are represented by delegates.
• Statements containing several delegates are common when manipulating data with LINQ to Objects.
• Executing delegates is only part of LINQ.
• A different representation of the operations in the pipeline is needed to use databases and other query engines efficiently.
• This is a way to treat code as data that can be examined programmatically.
• The logic within the operations can be transformed into a different form, such as a web service call or SQL query.

Lambdas

• Lambdas can create delegate instances, and the C# compiler can transform them into expression trees.
• Expression trees are data structures representing the logic of lambda expressions, which other code can examine.
• Lambda expressions are the idiomatic way of representing operations in LINQ data pipelines.
• Lambda expressions are an evolution of anonymous methods from C# 2.
• Lambda expressions can do almost everything that anonymous methods achieve.
• Lambda Expressions are usually more readable and compact. Anonymous methods have no access modifier or name.
• Lambda expressions have special conversion rules, like anonymous methods.
• The type of a lambda expression is not a delegate type itself, but it can be converted into a delegate instance implicitly and explicitly.
• The term "anonymous function" covers both anonymous methods and lambda expressions, and in many cases, the same conversion rules apply to both.

Func Delegate Types

• Func<string, double, int> is equivalent to public delegate int SomeDelegate(string arg1, double arg2).
• Each delegate signature takes between zero and four type parameters, but a Func<> declaration can include up to 16 parameters.
• The last type parameter is used for the return type in each case.

Action Delegate Types

• The Action<...> set of delegates provides equivalent functionality for a void return type:
  • Action<T>(T arg)

Anonymous Method Example

• Func<string,int> returnLength;
• returnLength = delegate (string text) { return text.Length; };
• Console.WriteLine(returnLength("Hello"));

Lambda Expression Example: General Form

• Func<string,int> returnLength;
• returnLength = (string text) => { return text.Length; };
• Console.WriteLine(returnLength("Hello"));
• In general form => is the lambda declaration operator; it means "goes to" and separates the parameter list (LHS) from the method body (RHS).

Lambda Expression Example: Simplified Form

• (explicitly-typed-parameter-list) => expression
• (string text) => text.Length
• And, without parentheses:
• string text => text.Length
• An implicitly typed parameter list is a comma-separated list of names without types.
• You can't mix and match explicitly and implicitly typed parameters.
• The whole list must be explicitly typed, or implicitly typed.
• Explicit typing is required if any parameters are out or ref parameters.
• text => text.Length

Lambda Syntax

• Start with an anonymous method: delegate (string text) { return text.Length; }
  • Convert to lambda expression: (string text) => { return text.Length; }
  • Single expression, so no braces required: (string text) => text.Length
  • Let the compiler infer the parameter type: (text) => text.Length
  • Remove unnecessary parentheses: text => text.Length

List<T> Example

• Lists can be filtered, sorted and have actions performed on them.
• An example of this is in relation to Film

Example: Handler Definition

• static void Log(string title, object sender, EventArgs e) { Console.WriteLine($"Event: {title} "); Console.WriteLine($"Sender: {sender} "); Console.WriteLine($"Arguments: {e.GetType()} "); foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(e)) { string name = prop.DisplayName; object? value = prop.GetValue(e); Console.WriteLine($"\t{name}={value}"); } }

Example: Handler Registration

• Button button = new Button { Text = "Click me"; };
• button.Click += (src, e) => Log("Click", src, e);
• button.KeyPress += (src, e) => Log("KeyPress", src, e);
• button.MouseHover += (src, e) => Log("MouseHover", src, e);
• button.MouseWheel += (src, e) => Log("MouseWheel", src, e);
• Form form = new Form { AutoSize = true, Controls = { button } };
• Application.Run(form);

Activity

• Follow the film example steps, and use Lambda expressions to write different lists of students (first name, last name, age to the console according to the following conditions:
  • A complete list containing the full name (first name combined + last name) and age.
  • A shorted list of those students older than 20.
  • A complete list sorted by age.
  • Test your application with at least 4 students.

Expression Trees

• Although the idea of treating code as data is old, it hasn't been used much in programming.
• All .NET programs use the concept because the IL code is treated as data by the JIT, which converts it to native code.
• Expression trees in .NET provide an abstract way of representing code as a tree of objects.
• The primary use of expression trees is in LINQ.
• C# provides built-in support for converting lambda expressions to expression trees.

Simple Expression Tree Example

• Adding 2 and 3 can be represented as an expression tree.
• Expression firstArg = Expression.Constant(2);
• Expression secondArg = Expression.Constant(3);
• Expression add = Expression.Add(firstArg, secondArg);
• Console.WriteLine(add);
• Leaf expressions are created first in the code and it is built from the bottom up.
• Expressions are immutable once they are created. Once an expression exists, it will never change, so you can cache and reuse expressions at will.

Converting C# Lambda Expressions

• The compiler can build expression trees from lambda expressions.
• This creates instances of Expression<TDelegate> at execution time.
• Example:
  • Expression<Func> return5 = () => 5;
  • Func compiled = return5.Compile();
  • Console.WriteLine(compiled);
• More complex examples with parameters:
  • Expression<Func<string, string, bool>> expression = (x,y) => x.StartsWith(y);
  • var compiled = expression.Compile();
  • Console.WriteLine(compiled("First", "Second"));
  • Console.WriteLine(compiled("First", "Fir"));

Usefulness

• Expression trees would have little value without lambda expressions.
• Lambda expressions would be less useful without expression trees.
• Combining lambda expressions, expression trees, and extension methods gives "the language of LINQ".
• Lambda expressions provide compile-time checks with expression trees, which abstract the execution model away from the desired logic.
• At the heart of out-of-process LINQ providers is the idea that an expression tree can be created from a familiar source language (C#) and used as an intermediate format, converted into the target platform's native language (SQL).