Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How LINQ works internally?

Tags:

linq

I love using LINQ in .NET, but I want to know how that works internally?

like image 394
rpf Avatar asked Mar 22 '09 16:03

rpf


People also ask

How do LINQ queries work?

LINQ simplifies this situation by offering a consistent model for working with data across various kinds of data sources and formats. In a LINQ query, you are always working with objects. You use the same basic coding patterns to query and transform data in XML documents, SQL databases, ADO.NET Datasets, .

How are LINQ queries executed?

LINQ queries are always executed when the query variable is iterated over, not when the query variable is created. This is called deferred execution. You can also force a query to execute immediately, which is useful for caching query results.

What is LINQ and how when is it used?

LINQ is a data querying API that provides querying capabilities to . NET languages with a syntax similar to a SQL. LINQ queries use C# collections to return data. LINQ in C# is used to work with data access from sources such as objects, data sets, SQL Server, and XML.


2 Answers

It makes more sense to ask about a particular aspect of LINQ. It's a bit like asking "How Windows works" otherwise.

The key parts of LINQ are for me, from a C# perspective:

  • Expression trees. These are representations of code as data. For instance, an expression tree could represent the notion of "take a string parameter, call the Length property on it, and return the result". The fact that these exist as data rather than as compiled code means that LINQ providers such as LINQ to SQL can analyze them and convert them into SQL.
  • Lambda expressions. These are expressions like this:

    x => x * 2 (int x, int y) => x * y () => { Console.WriteLine("Block"); Console.WriteLine("Lambda"); } 

    Lambda expressions are converted either into delegates or expression trees.

  • Anonymous types. These are expressions like this:

    new { X=10, Y=20 } 

    These are still statically typed, it's just the compiler generates an immutable type for you with properties X and Y. These are usually used with var which allows the type of a local variable to be inferred from its initialization expression.

  • Query expressions. These are expressions like this:

    from person in people where person.Age < 18 select person.Name 

    These are translated by the C# compiler into "normal" C# 3.0 (i.e. a form which doesn't use query expressions). Overload resolution etc is applied afterwards, which is absolutely key to being able to use the same query syntax with multiple data types, without the compiler having any knowledge of types such as Queryable. The above expression would be translated into:

    people.Where(person => person.Age < 18)       .Select(person => person.Name) 
  • Extension methods. These are static methods which can be used as if they were instance methods of the type of the first parameter. For example, an extension method like this:

    public static int CountAsciiDigits(this string text) {     return text.Count(letter => letter >= '0' && letter <= '9'); } 

    can then be used like this:

    string foo = "123abc456"; int count = foo.CountAsciiDigits(); 

    Note that the implementation of CountAsciiDigits uses another extension method, Enumerable.Count().

That's most of the relevant language aspects. Then there are the implementations of the standard query operators, in LINQ providers such as LINQ to Objects and LINQ to SQL etc. I have a presentation about how it's reasonably simple to implement LINQ to Objects - it's on the "Talks" page of the C# in Depth web site.

The way providers such as LINQ to SQL work is generally via the Queryable class. At their core, they translate expression trees into other query formats, and then construct appropriate objects with the results of executing those out-of-process queries.

Does that cover everything you were interested in? If there's anything in particular you still want to know about, just edit your question and I'll have a go.

like image 192
Jon Skeet Avatar answered Sep 23 '22 18:09

Jon Skeet


LINQ is basically a combination of C# 3.0 discrete features of these:

  • local variable type inference
  • auto properties (not implemented in VB 9.0)
  • extension methods
  • lambda expressions
  • anonymous type initializers
  • query comprehension

For more information about the journey to get there (LINQ), see this video of Anders in LANGNET 2008:

http://download.microsoft.com/download/c/e/5/ce5434ca-4f54-42b1-81ea-7f5a72f3b1dd/1-01%20-%20CSharp3%20-%20Anders%20Hejlsberg.wmv

like image 32
Eriawan Kusumawardhono Avatar answered Sep 22 '22 18:09

Eriawan Kusumawardhono