Skip Navigation LinksHome > Categories > Code from a Category

LINQ - Language-Integrated Query



User Name: codelecturer
Name: Mike Chauhan
Contact Me: www.datawebcoder.com/ContactUs.aspx
Home Page: www.datawebcoder.com
6 years of total IT experience including programming, application development, System Maintenance . 3 years of Experienced and expertise in .Net Framework VB, Visual Basic.Net, ASP.Net 2.0, 3.5 and AD... [More]
Viewed Times: 966
Add Date: 12/07/2012
In this article we will take a look at fundamentals of LINQ - Language-Integrated Query

What is LINQ?

A common development task is to query information, extracting a filtered list of items that may be ordered, grouped or aggregated. The data may be retrieved from an existing in-memory collection, a database, an XML file or many other sources. Usually, the type of the data source being examined dictates the syntax of the query, which may vary greatly, reducing the code's portability. Often the query will be generated within a string.

This increases the risk of invalid or inaccurate queries as the strings will include no syntax checking and little or no support from the integrated development environment (IDE). To alleviate these problems, Microsoft introduced language-integrated query (LINQ) into the .NET framework version 3.5. LINQ provides a set of standard query operators that can be used to perform simple or complex queries against a number of different data sources. The queries are integrated with other source code written in .NET languages such as C# or Visual Basic.

This allows Visual Studio to provide syntax checking and Intellisense support. In this tutorial we will be examining LINQ to Objects, which allows you to execute queries against in-memory data structures. Further LINQ providers are available to allow querying against SQL Server databases, XML, DataSets and many other data sources. You can also create your own providers to attach to domain-specific information.

A number of new features were added to the .NET framework and the C# programming language that provide support for LINQ. Extension methods and lambda expressions are used extensively to build queries. To allow data to be returned from a query without the need to first define a class or structure, LINQ often generates results using anonymous types. In addition, the previously available generics features are important. If you are unsure of any of these topics, follow the links to find articles describing them.

Standard Query Operators

The System.Linq namespace contains a number of standard query operators. These are extension methods that are available for all classes that implement the IEnumerable or generic IEnumerable interfaces. The methods allow collections to be queried, aggregated and sorted. The methods can be chained together to generate more complex queries. The easiest way to understand the query operators is to see them in action. Try executing the following code in a console application. Ensure you include a using directive for the System.IO namespace.


The above sample is quite simple but performs a task that would otherwise require several lines of code instead of just one. The first line is the important one. It retrieves a filtered list of folders from the path "C:\". The Where operator and its lambda expression parameter specifies that only paths that are greater than ten characters in length are retrieved. The OrderBy method sorts the results according to their length. The remainder of the code simply outputs the results of the operation.

One of the advantages of LINQ is that it employs a declarative style of programming, whereas standard C# provides imperative code. Imperative programming requires that you specify exactly how an algorithm operates. An imperative version of the previous sample code would require that you used a loop and an if statement to determine which folder names should be added to a collection. You would then implement a sorting algorithm to order the results. The declarative approach adds a layer of abstraction, allowing you to specify what you wish to achieve without knowing the underlying algorithms that will be applied.

Query Expression Syntax

In addition to the standard query operators, LINQ provides a new query syntax. This allows queries to be created in a format that some developers find more natural. The queries are similar to those used with structured query language (SQL) for querying databases. We can recreate the previous example using the query syntax as follows:


The above query is quite easy to read. Although it is actually a single statement I have separated it into several lines to highlight the key operations. Firstly, the data source is specified with the from keyword. Secondly, the filter is applied by the where clause. The sort order is determined by the orderby element and the items to include in the results are specified in the select element.

Deferred Execution

At first glance, you might imagine that the LINQ queries described above return a collection of strings as soon as the line of code is processed. In reality, LINQ employs deferred execution, or lazy loading. Queries that return a single value or object do execute immediately. However, those that return a list of items are usually not executed until the first time that the results are used.

Deferred execution provides several benefits. If you have a number of queries, with each retrieving details from the results of another, the queries can be combined into a single operation. With LINQ to Objects this reduces the memory overhead that would be required for the interim lists and potentially improves the query's performance. For other LINQ providers it may minimise network traffic or database activity. The main disadvantage to this approach is that you can be surprised by the results of a query if the data changes after the query is defined but before it is executed.

We can demonstrate deferred execution by running the following sample code. This creates a list of strings containing three items and then defines a query that returns all values from the list. Following the query line, another item is added to the original source list and the results of the query are outputted to the console. If the query had been executed when it was encountered, the "values" variable would contain three results. However, because the query is executed when the results are first read, the additional value is included and four strings are outputted to the console.

LINQ to Objects Tutorial

The articles in this tutorial will describe the use of LINQ to Objects for querying in-memory data structures. The first group of articles will describe how to construct queries using basic operators and query expression syntax. This will include how information from multiple sources can be joined and how to aggregate numeric data. The later articles will describe groups of related standard query operators.

Happy Programming!!!

Post a Comment

Name: (Optional)
Email: (Optional, you can get an email if somebody replys your comments)*
Email me if somebody respons my comment below:
Details**:
Enter Text
as Below:
(case insensitive, if hard to read, click the "get a new one" button)
 
    
* Your email address will not be shared with any third parties for any reason.
** Maximum 1000 charactors.