A little review for those that never really embraced the
beginnings of LINQ:
LINQ is an acronym for Language
Integrated Query which allows you to write structured type-safe queries over
object collections. It was new as of .NET 3.0 in C#. The basic LINQ query can
be run over any collection implementing IEnumerable<> and are compile-type
checked. The core namespaces supporting LINQ are System.Linq and
System.Linq.Expressions in the Systems.Core assembly.
The basic units of LINQ are
sequences and elements. A sequence is any object that implements the generic
IEnumerable interface and an element is each item in the sequence.
string[] michael = { "Jon", "Mikal", "Brad" };
In this example Michael is the sequence and Jon, Brad
and Mikal are the elements.
A query operator is
a method that transforms a sequence. In the Enumerable class in System.Linq
there are around 40 query operators, all implemented as static extension
methods, called standard query operators. A query
is an expression that transforms sequences with query operators. The most basic
queries have one input sequences and one operator. In the following example,
the Where operator is applied on a simple array to extract those names that
have at least 4 letters:
string[] michael = { "Jon", "Mikal", "Brad" };
IEnumerable<string> filtered = Enumerable.Where( michael, m => m.Length >= 4 );
foreach ( var item in filtered )
{
Console.WriteLine( item + "|" ); //
Mikal|Brad|
}
This query could further be
shortened by implicitly typing michael:
var filtered =
michael.Where( m => m.Length >= 4 );
Most query operators take a lambda
expression as an argument. This expression helps shape the query, the lambda
expression from above is:
m => m.Length >= 4
The input
argument, in this case m corresponds to
an input element. In the above example the input argument represents the names
in the array and is of type string. This operator, Where,
requires that the lambda expression return a boolean value which if true in
this case means the element should be included in the output sequence. These
types of queries are commonly referred to as lambda queries.
There is also in C# a special syntax for writing these queries called query
comprehension syntax. The above lambda query can be re-written in query
comprehension syntax as follows:
IEnumerable<string> filtered = from m in michael
where m.Length >= 4
select m;
Both
types of queries work together to provide a much easier way of iterating
elements in a sequence.
Posts
