Language Integrated Query

Short description: Microsoft .NET Framework component

"LINQ" redirects here. For other uses, see Linq (disambiguation).

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages)

This article contains instructions, advice, or how-to content. The purpose of Wikipedia is to present facts, not to train. Please help improve this article either by rewriting the how-to content or by moving it to Wikiversity, Wikibooks or Wikivoyage. (September 2024)

|

(Learn how and when to remove this template message)

Language Integrated QueryDesigned by| Microsoft Corporation

|

Developer| Microsoft Corporation
Typing discipline| Strongly typed
Website| learn.microsoft.com/en-us/dotnet/standard/linq
Major implementations
.NET languages (C#, F#, VB.NET)
Influenced by
SQL, Haskell

Language Integrated Query (LINQ, pronounced "link") is a Microsoft .NET framework component that adds native data querying abilities to .NET languages, originally released as a major part of .NET Framework 3.5 in 2007.

LINQ extends the language by the addition of query expressions, which are akin to SQL statements, and can be used to conveniently extract and process data from arrays, enumerable classes, XML documents, relational databases, and third-party data sources. Other uses, which utilize query expressions as a general framework for readably composing arbitrary computations, include the construction of event handlers[1] or monadic parsers.[2] It also defines a set of method names (called standard query operators, or standard sequence operators), along with translation rules used by the compiler to translate query syntax expressions into expressions using fluent-style (called method syntax by Microsoft) with these method names, lambda expressions and anonymous types.

## Contents

* 1 Architecture
* 1.1 Standard query operator API
* 1.2 Language extensions
* 1.3 LINQ providers
* 1.3.1 LINQ to Objects
* 1.3.2 LINQ to XML (formerly named XLINQ)
* 1.3.3 LINQ to SQL (formerly named DLINQ)
* 1.3.4 LINQ to DataSets
* 2 Performance
* 3 PLINQ
* 4 Predecessor languages
* 5 Ports
* 6 See also
* 7 References
* 8 External links

## Architecture

### Standard query operator API

In what follows, the descriptions of the operators are based on the application of working with collections. Many of the operators take other functions as arguments. These functions may be supplied in the form of a named method or anonymous function.

The set of query operators defined by LINQ is exposed to the user as the Standard Query Operator (SQO) application programming interface (API). The query operators supported by the API are:[3]

Select

The Select operator performs a projection on the collection to select interesting aspects of the elements. The user supplies an arbitrary function, in the form of a named or lambda expression, which projects the data members. The function is passed to the operator as a delegate. This implements the Map higher-order function.
Where

The Where operator allows the definition of a set of predicate rules that are evaluated for each object in the collection, while objects that do not match the rule are filtered away. The predicate is supplied to the operator as a delegate. This implements the Filter higher-order function.
SelectMany

For a user-provided mapping from collection elements to collections, semantically two steps are performed. First, every element is mapped to its corresponding collection. Second, the result of the first step is flattened by one level. Select and Where are both implementable in terms of SelectMany, as long as singleton and empty collections are available. The translation rules mentioned above still make it mandatory for a LINQ provider to provide the other two operators. This implements the bind higher-order function.
Sum / Min / Max / Average

These operators optionally take a function that retrieves a certain numeric value from each element in the collection and uses it to find the sum, minimum, maximum or average values of all the elements in the collection, respectively. Overloaded versions take no function and act as if the identity is given as the lambda.

Aggregate

A generalized Sum / Min / Max. This operator takes a function that specifies how two values are combined to form an intermediate or the final result. Optionally, a starting value can be supplied, enabling the result type of the aggregation to be arbitrary. Furthermore, a finalization function, taking the aggregation result to yet another value, can be supplied. This implements the Fold higher-order function.

Join / GroupJoin
The Join operator performs an inner join on two collections, based on matching keys for objects in each collection. It takes two functions as delegates, one for each collection, that it executes on each object in the collection to extract the key from the object. It also takes another delegate in which the user specifies which data elements, from the two matched elements, should be used to create the resultant object. The GroupJoin operator performs a group join. Like the Select operator, the results of a join are instantiations of a different class, with all the data members of both the types of the source objects, or a subset of them.
Take / TakeWhile
The Take operator selects the first n objects from a collection, while the TakeWhile operator, which takes a predicate, selects those objects that match the predicate (stopping at the first object that doesn't match it).
Skip / SkipWhile
The Skip and SkipWhile operators are complements of Take and TakeWhile - they skip the first n objects from a collection, or those objects that match a predicate (for the case of SkipWhile).
OfType
The OfType operator is used to select the elements of a certain type.
Concat
The Concat operator concatenates two collections.
OrderBy / ThenBy
The OrderBy operator is used to specify the primary sort ordering of the elements in a collection according to some key. The default ordering is in ascending order, to reverse the order, the OrderByDescending operator is to be used. ThenBy and ThenByDescending specifies subsequent ordering of the elements. The function to extract the key value from the object is specified by the user as a delegate.
Reverse
The Reverse operator reverses a collection.
GroupBy
The GroupBy operator takes a function that extracts a key value and returns a collection of `IGrouping<Key, Values>` objects, for each distinct key value. The `IGrouping` objects can then be used to enumerate all the objects for a particular key value.
Distinct
The Distinct operator removes duplicate instances of an object from a collection. An overload of the operator takes an equality comparer object which defines the criteria for distinctness.
Union / Intersect / Except
These operators are used to perform a union, intersection and difference operation on two sequences, respectively. Each has an overload which takes an equality comparer object which defines the criteria for element equality.
SequenceEqual
The SequenceEqual operator determines whether all elements in two collections are equal and in the same order.
First / FirstOrDefault / Last / LastOrDefault
These operators take a predicate. The First operator returns the first element for which the predicate yields true, or, if nothing matches, throws an exception. The FirstOrDefault operator is like the First operator except that it returns the default value for the element type (usually a null reference) in case nothing matches the predicate. The last operator retrieves the last element to match the predicate, or throws an exception in case nothing matches. The LastOrDefault returns the default element value if nothing matches.
Single
The Single operator takes a predicate and returns the element that matches the predicate. An exception is thrown, if none or more than one element match the predicate.
SingleOrDefault
The SingleOrDefault operator takes a predicate and return the element that matches the predicate. If more than one element matches the predicate, an exception is thrown. If no element matches the predicate, a default value is returned.
ElementAt
The ElementAt operator retrieves the element at a given index in the collection.
Any / All
The Any operator checks, if there are any elements in the collection matching the predicate. It does not select the element, but returns true if at least one element is matched. An invocation of any without a predicate returns true if the collection non-empty. The All operator returns true if all elements match the predicate.
Contains
The Contains operator checks, if the collection contains a given element.
Count
The Count operator counts the number of elements in the given collection. An overload taking a predicate, counts the number of elements matching the predicate.

The standard query operator API also specifies certain operators that convert a collection into another type:[3]

* AsEnumerable: Statically types the collection as an `IEnumerable<T>`.[4]
* AsQueryable: Statically types the collection as an `IQueryable<T>`.
* ToArray: Creates an array `T[]` from the collection.
* ToList: Creates a `List<T>` from the collection.
* ToDictionary: Creates a `Dictionary<K, T>` from the collection, indexed by the key K. A user supplied projection function extracts a key from each element.
* ToLookup: Creates a `Lookup<K, T>` from the collection, indexed by the key K. A user supplied projection function extracts a key from each element.
* Cast: converts a non-generic `IEnumerable` collection to one of `IEnumerable<T>` by casting each element to type `T`. Alternately converts a generic `IEnumerable<T>` to another generic `IEnumerable<R>` by casting each element from type `T` to type `R`. Throws an exception in any element cannot be cast to the indicated type.
* OfType: converts a non-generic `IEnumerable` collection to one of `IEnumerable<T>`. Alternately converts a generic `IEnumerable<T>` to another generic `IEnumerable<R>` by attempting to cast each element from type `T` to type `R`. In both cases, only the subset of elements successfully cast to the target type are included. No exceptions are thrown.

### Language extensions

While LINQ is mainly implemented as a library for .NET Framework 3.5, it also defines optional language extensions that make queries a first-class language construct and provide syntactic sugar for writing queries. These language extensions have initially been implemented in C# 3.0,[5]: 75 VB 9.0, F#[6] and Oxygene, with other languages like Nemerle having announced preliminary support. The language extensions include:[7]

* Query syntax: A language is free to choose a query syntax that it will recognize natively. These language keywords must be translated by the compiler to appropriate LINQ method calls.
* Implicitly typed variables: This enhancement allows variables to be declared without specifying their types. The languages C# 3.0[5]: 367 and Oxygene declare them with the `var` keyword. In VB9.0, the `Dim` keyword without type declaration accomplishes the same. Such objects are still strongly typed; for these objects the compiler infers the types of variables via type inference, which allows the results of the queries to be specified and defined without declaring the type of the intermediate variables.
* Anonymous types: Anonymous types allow classes that contain only data-member declarations to be inferred by the compiler. This is useful for the Select and Join operators, whose result types may differ from the types of the original objects. The compiler uses type inference to determine the fields contained in the classes and generates accessors and mutators for these fields.
* Object initializer: Object initializers allow an object to be created and initialized in a single scope, as required for Select and Join operators.
* Lambda expressions: Lambda expressions allow predicates and other projection functions to be written inline with a concise syntax, and support full lexical closure. They are captured into parameters as delegates or expression trees depending on the Query Provider.

For example, in the query to select all the objects in a collection with `SomeProperty` less than 10,

IEnumerable<MyObject> SomeCollection = /* something here */

IEnumerable<MyObject> results = from c in SomeCollection
where c.SomeProperty < 10
select new {c.SomeProperty, c.OtherProperty};

foreach (MyObject result in results)

Console.WriteLine(result);

the types of variables result, c and results all are inferred by the compiler in accordance to the signatures of the methods eventually used. The basis for choosing the methods is formed by the query expression-free translation result

IEnumerable<MyObject> results =
SomeCollection
.Where(c => c.SomeProperty < 10)
.Select(c => new {c.SomeProperty, c.OtherProperty});

results.ForEach(x => {Console.WriteLine(x.ToString());})

### LINQ providers

The C#3.0 specification defines a Query Expression Pattern along with translation rules from a LINQ expression to an expression in a subset of C# 3.0 without LINQ expressions. The translation thus defined is actually un-typed, which, in addition to lambda expressions being interpretable as either delegates or expression trees, allows for a great degree of flexibility for libraries wishing to expose parts of their interface as LINQ expression clauses. For example, LINQ to Objects works on `IEnumerable<T>`s and with delegates, whereas LINQ to SQL makes use of the expression trees.

The expression trees are at the core of the LINQ extensibility mechanism, by which LINQ can be adapted for many data sources. The expression trees are handed over to LINQ Providers, which are data source-specific implementations that adapt the LINQ queries to be used with the data source. If they choose so, the LINQ Providers analyze the expression trees contained in a query in order to generate essential pieces needed for the execution of a query. This can be SQL fragments or any other completely different representation of code as further manipulatable data. LINQ comes with LINQ Providers for in-memory object collections, Microsoft SQL Server databases, ADO.NET datasets and XML documents. These different providers define the different flavors of LINQ:

#### LINQ to Objects

The LINQ to Objects provider is used for in-memory collections, using the local query execution engine of LINQ. The code generated by this provider refers to the implementation of the standard query operators as defined on the `Sequence` pattern and allows `IEnumerable<T>` collections to be queried locally. Current implementation of LINQ to Objects perform interface implementation checks to allow for fast membership tests, counts, and indexed lookup operations when they are supported by the runtime type of the IEnumerable.[8][9][10]

#### LINQ to XML (formerly named XLINQ)

The LINQ to XML provider converts an XML document to a collection of `XElement` objects, which are then queried against using the local execution engine that is provided as a part of the implementation of the standard query operator.[11] The LINQ to XML provider converts an XML document to a collection of `XElement ` objects, which are then queried against using the local execution engine that is provided as a part of the implementation of the standard query operator.[12]

#### LINQ to SQL (formerly named DLINQ)

The LINQ to SQL provider allows LINQ to be used to query Microsoft SQL Server databases, including SQL Server Compact databases. Since SQL Server data may reside on a remote server, and because SQL Server has its own query engine, LINQ to SQL does not use the query engine of LINQ. Instead, it converts a LINQ query to a SQL query that is then sent to SQL Server for processing.[13] However, since SQL Server stores the data as relational data and LINQ works with data encapsulated in objects, the two representations must be mapped to one another. For this reason, LINQ to SQL also defines a mapping framework. The mapping is done by defining classes that correspond to the tables in the database, and containing all or a subset of the columns in the table as data members.[14] The correspondence, along with other relational model attributes such as primary keys, are specified using LINQ to SQL-defined attributes. For example,

[Table(Name="Customers")]
public class Customer

[Column(IsPrimaryKey = true)]
public int CustID;

[Column]
public string CustName;

This class definition maps to a table named `Customers` and the two data members correspond to two columns. The classes must be defined before LINQ to SQL can be used. Visual Studio 2008 includes a mapping designer that can be used to create the mapping between the data schemas in the object as well as the relational domain. It can automatically create the corresponding classes from a database schema, as well as allow manual editing to create a different view by using only a subset of the tables or columns in a table.[14]

The mapping is implemented by the `DataContext` that takes a connection string to the server, and can be used to generate a `Table<T>` where T is the type to which the database table will be mapped. The `Table<T>` encapsulates the data in the table, and implements the `IQueryable<T>` interface, so that the expression tree is created, which the LINQ to SQL provider handles. It converts the query into T-SQL and retrieves the result set from the database server. Since the processing happens at the database server, local methods, which are not defined as a part of the lambda expressions representing the predicates, cannot be used. However, it can use the stored procedures on the server. Any changes to the result set are tracked and can be submitted back to the database server.[14]

#### LINQ to DataSets

Since the LINQ to SQL provider (above) works only with Microsoft SQL Server databases, in order to support any generic database, LINQ also includes the LINQ to DataSets. It uses ADO.NET to handle the communication with the database. Once the data is in ADO.NET Datasets, LINQ to DataSets execute queries against these datasets.[15]

## Performance

Parts of this article (those related to Performance) need to be updated. The reason given is: The source is old and now performs better than before. Please update this article to reflect recent events or newly available information. (November 2021)

|

Non-professional users may struggle with subtleties in the LINQ to Objects features and syntax. Naive LINQ implementation patterns can lead to a catastrophic degradation of performance.[16][17]

LINQ to XML and LINQ to SQL performance compared to ADO.NET depends on the use case.[18][19]

## PLINQ

Version 4 of the .NET framework includes Parallel Extensions for Parallel LINQ (PLINQ), a parallel execution engine for LINQ queries. It defines the `ParallelQuery<T>` class. Any implementation of the `IEnumerable<T>` interface can take advantage of the PLINQ engine by calling the `AsParallel<T>(this IEnumerable<T>)` extension method defined by the ParallelEnumerable class in the System.Linq namespace of the .NET framework.[20] The PLINQ engine can execute parts of a query concurrently on multiple threads, providing faster results.[21]

## Predecessor languages

Many of the concepts that LINQ introduced were originally tested in Microsoft's Cω research project, formerly known by the codenames X# (X Sharp) and Xen. It was renamed to Cω after Polyphonic C# (another research language based on join calculus principles) was integrated into it.

Cω attempts to make datastores (such as databases and XML documents) accessible with the same ease and type safety as traditional types like strings and arrays. Many of these ideas were inherited from an earlier incubation project within the WebData XML team called X# and Xen. Cω also includes new constructs to support concurrent programming; these features were largely derived from the earlier Polyphonic C# project.[22]

First available in 2004 as a compiler preview, Cω's features were subsequently used by Microsoft in the creation of the LINQ features released in 2007 in .NET version 3.5[23] The concurrency constructs have also been released in a slightly modified form as a library, named Joins Concurrency Library, for C# and other .NET languages by Microsoft Research.[24]

## Ports

Ports of LINQ exist for PHP (PHPLinq ), JavaScript (linq.js), TypeScript (linq.ts), and ActionScript (ActionLinq ), and C++ (CXXIter), although none are strictly equivalent to LINQ in the .NET inspired languages C#, F# and VB.NET (where it is a part of the language, not an external library, and where it often addresses a wider range of needs).

## See also

* Object-relational mapping (ORM)
* Object-relational impedance mismatch
* List comprehension
* Lazy evaluation

## References

1. ↑ "Rx framework". 10 June 2011. http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx.
2. ↑ "Monadic Parser Combinators using C#3". http://blogs.msdn.com/lukeh/archive/2007/08/19/monadic-parser-combinators-using-c-3-0.aspx.
3. ↑ 3.0 3.1 "Standard Query Operators". Microsoft. http://download.microsoft.com/download/5/8/6/5868081c-68aa-40de-9a45-a3803d8134b8/standard_query_operators.doc.
4. ↑ "Enumerable Class". msdn. Microsoft. http://msdn.microsoft.com/en-us/library/system.linq.enumerable(v=vs.110).aspx.
5. ↑ 5.0 5.1 Skeet, Jon (23 March 2019). C# in Depth. Manning. ISBN 978-1617294532.
6. ↑ "Query Expressions (F#)". https://docs.microsoft.com/en-gb/dotnet/fsharp/language-reference/query-expressions.
7. ↑ "LINQ Framework". http://msdn.microsoft.com/en-us/library/bb397921.aspx.
8. ↑ "Enumerable.ElementAt". http://msdn.microsoft.com/en-us/library/bb299233.aspx.
9. ↑ "Enumerable.Contains". http://msdn.microsoft.com/en-us/library/bb352880.aspx.
10. ↑ "Enumerable.Count". http://msdn.microsoft.com/en-us/library/bb338038.aspx.
11. ↑ ".NET Language-Integrated Query for XML Data". 30 April 2007. http://msdn2.microsoft.com/hi-in/library/bb308960(en-us).aspx.
12. ↑ ".NET Language-Integrated Query for XML Data". 30 April 2007. http://msdn2.microsoft.com/hi-in/library/bb308960(em-us).aspx.
13. ↑ "LINQ to SQL". http://www.hookedonlinq.com/LINQtoSQL5MinuteOverview.ashx.
14. ↑ 14.0 14.1 14.2 "LINQ to SQL: .NET Language-Integrated Query for Relational Data". 30 April 2007. http://msdn2.microsoft.com/hi-in/library/bb425822.aspx.
15. ↑ "LINQ to DataSets". http://www.hookedonlinq.com/LINQtoDatasets.ashx.
16. ↑ Vider, Guy (2007-12-21). "LINQ Performance Test: My First Visual Studio 2008 Project". http://www.codeproject.com/KB/dotnet/LINQ_Performance_Test.aspx.
17. ↑ Parsons, Jared (2008). "Increase LINQ Query Performance". Microsoft Developer Network. http://msdn.microsoft.com/en-us/magazine/cc721610.aspx. "While it is true that LINQ is powerful and very efficient, large sets of data can still cause unexpected performance problems"
18. ↑ Alva, Jaime (2010-08-06). "Potential Performance Issues with Compiled LINQ Query Re-Compiles". Microsoft Developer Network. http://blogs.msdn.com/b/appfabriccat/archive/2010/08/06/potential-performance-issues-with-compiled-linq-query-re-compiles.aspx?. "When calling a query multiple times with Entity Framework the recommended approach is to use compiled LINQ queries. Compiling a query results in a performance hit the first time you use the query but subsequent calls execute much faster"
19. ↑ Kshitij, Pandey (2008-05-25). "Performance comparisons LinQ to SQL, ADO, C#". http://www.codeproject.com/KB/dotnet/LinQ_Performance_net3_5.aspx.
20. ↑ "ParallelEnumerable Class". http://msdn.microsoft.com/en-us/library/dd413602(v=vs.110).aspx.
21. ↑ "Programming in the Age of Concurrency: Concurrent Programming with PFX". http://channel9.msdn.com/Showpost.aspx?postid=347531.
22. ↑ Eichert, Steve; Wooley, James B.; Marguerie, Fabrice (2008). LINQ in Action. Manning. pp. 56–57 (as reported in the Google Books search link - the book does not have page numbers). ISBN 9781638354628.
23. ↑ Concepts behind the C# 3.0 language |Articles |TomasP.Net
24. ↑ "The Joins Concurrency Library". http://research.microsoft.com/research/pubs/view.aspx?type=inproceedings&id=2005.

## External links

| Wikibooks has a book on the topic of: .NET Development Foundation

|

* Official website, Microsoft
* LINQ to Objects for the .NET developer
* Future of LINQ to SQL
* How does it work in C#? - Part 3 (C# LINQ in detail)

* v
* t
* e

.NET Framework

* Version history
* .NET strategy

Architecture|

* Common Language Runtime (CLR)
* COM Interop
* Framework Class Library (FCL)

Components|

* ADO.NET
* Entity Framework
* ASP.NET
* Web Forms
* AJAX
* Core
* Dynamic Data
* MVC
* Razor
* ClickOnce
* Dynamic Language Runtime
* Extensible Application Markup Language (XAML)
* Language Integrated Query (LINQ)
* Managed Extensibility Framework
* Microsoft Silverlight
* Microsoft XNA
* Parallel Extensions
* Windows Communication Foundation (WCF)
* WCF Data Services
* Windows Forms (WinForms)
* Windows Identity Foundation (WIF)
* Windows Presentation Foundation (WPF)
* Windows Workflow Foundation (WF)
* .NET Remoting

Tools|

| Decompilers|

* .NET Reflector
* dotPeek

|

Obfuscators|

* Dotfuscator
* SmartAssembly
* CodeArmor

Misc|

* CLR Profiler
* ILAsm
* .NET Compiler Platform
* Native Image Generator (NGen)
* XAMLPad

IDEs|

* Visual Studio
* Blend
* Express
* MonoDevelop
* SharpDevelop
* Xamarin Studio

Organizations|

* .NET Foundation
* Microsoft
* Xamarin

* Category
* List

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Language Integrated Query. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Language_Integrated_Query&oldid=4349145"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template