What is LINQ? The .NET Language Integrated QueryLINQ is built into the .NET framework and allows you to easily query and manipulate data across sources in a consistent manner.
This article is part of a series of articles. Please use the links below to navigate between the articles.
- Learn to Program in C# - Full Introduction to Programming Course
- Introdution to Programming - C# Programming Fundamentals
- Guide to C# Data Types, Variables and Object Casting
- C# Operators: Arithmetic, Comparison, Logical and more
- Application Flow Control and Control Structures in C#
- Introduction to Object Oriented Programming for Beginners
- Introduction to C# Object-Oriented Programming Part 2
- C# Collection Types (Array,List,Dictionary,HashTable and More)
- Error and Exception Handling in C#
- Events, Delegates and Extension Methods
- Complete Guide to File Handling in C# - Reading and Writing Files
- Introduction to XML and XmlDocument with C#
- What is LINQ? The .NET Language Integrated Query
- Introduction to Asynchronous Programming in C#
- Working with Databases using Entity Framework
- All About Reflection in C# To Read Metadata and Find Assemblies
- Debugging and Testing in C#
- Introduction to ASP.Net MVC Web Applications and C#
- Windows Application Development Using .Net and Windows Forms
- Assemblies and the Global Assembly Cache in C#
- Working with Resources Files, Culture & Regions in .Net
- The Ultimate Guide to Regular Expressions: Everything You Need to Know
LINQ (Language-Integrated Query) is a technology built into the .NET framework that will allow you to query and consistently easily and manipulate data across various sources. It doesn't matter if the data is an array or a database; the methods and syntax are the same.
LINQ is extremely powerful for working with data, and you can do many things by simply chaining commands along one line.
In this example, we can select from an array all the names with eight or fewer characters in length and order them alphabetically.
var names = new List<string>()
{
"Kealan Pemberton",
"Kurtis Hayward",
"Hilary Bray",
"Nylah Fitzpatrick",
"Brandon Hendrix",
"Najma Pike",
"Milosz Hester",
"Ayda Reilly"
};
var filteredNames = from name in names where name.Length <= 12 orderby name.Length select name;
foreach (var name in filteredNames)
Console.WriteLine(name); LINQ Query Syntax vs. Method Syntax
LINQ statements can be written in one of two ways. The first query syntax we have seen above is similar to the syntax used in SQL. The second method is more procedural, using methods to represent query functions. Here are two examples of the different syntaxes.
LINQ Query Suntax
var lastNames = from person in persons
where person.Age > 12
orderby person.LastName
select person.LastName; LINQ Method Syntax
var lastName = persons
.Where(person => person.Age > 12)
.OrderBy(person => person.LastName)
.Select(person => person.LastName); The person is declared once in the query syntax and used in the where, orderby, and select clauses. Using the method syntax, you have to redeclare the person each time in the lambda expressions.
The compiler processes the query; there isn't any performance difference, so the choice of which to use is up to the developer.
I prefer method syntax; it is good for generating LINQ queries dynamically with expression trees and such. Query syntax is better for complicated queries with many lets, joins, and nested projections.
I'll use method syntax for most of the tutorials on this site.
Filtering Data with LINQ
One of the most basic operations you can perform on a data set is to filter some of it out.
var names = new List<string>()
{
"Kealan Pemberton",
"Kurtis Hayward",
"Hilary Bray",
"Nylah Fitzpatrick",
"Brandon Hendrix",
"Najma Pike",
"Milosz Hester",
"Ayda Reilly"
};
var filteredNames = names.Where(x => x.Length <= 12)
foreach (var name in filteredNames)
Console.WriteLine(name); This filters out everything where the length is greater than 12.
We can add multiple conditions to the where clause to filter the results further.
var filteredNames = names.Where(x => x.Length <= 12 && x.Length > 5) We can also filter results to check whether a value is contained or not within another predefined list of values.
var numbers = new List<int>()
{
1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377
};
var excludedNumbers = new List<int>()
{
21, 89
};
var validNumbers = numbers.Where(n => !excludedNumbers.Contains(n));
foreach (var n in validNumbers)
Console.WriteLine(n); Sorting Data with LINQ
Another powerful and hugely useful method LINQ provides is data sorting. We can use OrderBy and OrderByDescending to sort our data.
var unorderedNumbers = new List<int>()
{
1, 13, 144, 2, 21, 233, 3, 34, 377, 5, 55, 8, 89
};
var orderedNumbers = unorderedNumbers.OrderBy(x => x); We can perform operations on complex objects as well.
class person
{
public string Name { get; set; }
public int Age { get; set; }
}
var persons = new List<person>()
{
new person()
{
Name = "Kealan Pemberton",
Age = 55
},
new person()
{
Name = "Kurtis Hayward",
Age = 21
},
new person()
{
Name = "Hilary Bray",
Age = 34
}
};
var sortedPersons = persons.OrderBy(x => x.Age); Limiting Data with LINQ
Now we have filtered and sorted the data, we can limit the number of records. This is especially useful when using a database as a data source because it often involves huge amounts of rows, which are resource-consuming to fetch.
The methods for limiting records are called Take() and Skip(), and in combination, they are great for doing pagination on a website.
Take specifies the number of records to return, and Skip specifies the number of results to skip before taking the records.
var names = new List<string>()
{
"Kealan Pemberton",
"Kurtis Hayward",
"Hilary Bray",
"Nylah Fitzpatrick",
"Brandon Hendrix",
"Najma Pike",
"Milosz Hester",
"Ayda Reilly"
};
var names = names.Skip(1).Take(2).ToList(); You often have a page size and a current page number for pagination.
var names = new List<string>()
{
"Kealan Pemberton",
"Kurtis Hayward",
"Hilary Bray",
"Nylah Fitzpatrick",
"Brandon Hendrix",
"Najma Pike",
"Milosz Hester",
"Ayda Reilly"
};
var pageSize = 5;
var currentPage = 1;
var results = names.Skip(pageSize * currentPage).Take(pageSize); Data Transformations with LINQ
Finally, we can transform the original data types to another type as part of the query. We can do this using the Select method. Consider the person's class previously, and suppose we want a list of names. We can select just the name part to return a list of strings.
class person
{
public string Name { get; set; }
public int Age { get; set; }
}
var persons = new List<person>()
{
new person()
{
Name = "Kealan Pemberton",
Age = 55
},
new person()
{
Name = "Kurtis Hayward",
Age = 21
},
new person()
{
Name = "Hilary Bray",
Age = 34
}
};
List<string> namesOnly = persons.Select(x => x.Name).ToList(); Grouping Results with LINQ
When you group data, you take a list of something and divide it into several groups based on one or several properties. With LINQ, this is very easy, even though using the GroupBy() method can be confusing initially.
var persons = new List<person>()
{
new person()
{
Name = "Kealan Pemberton",
Age = 55,
Country = "GB"
},
new person()
{
Name = "Kurtis Hayward",
Age = 21,
Country = "GB"
},
new person()
{
Name = "Hilary Bray",
Age = 34,
Country = "US"
}
};
var nameGroupedByCountry = persons.GroupBy(user => user.Country);
foreach (var group in nameGroupedByCountry)
{
Console.WriteLine("People from " + group.Key + ":");
foreach (var person in group)
Console.WriteLine("- " + person.Name);
} Chaining LINQ Queries
Now that we have seen the different methods, we can combine them to sort, filter, page, and select results in a single query.
var persons = new List<person>()
{
new person()
{
Name = "Kealan Pemberton",
Age = 55,
Country = "GB"
},
new person()
{
Name = "Kurtis Hayward",
Age = 21,
Country = "GB"
},
new person()
{
Name = "Hilary Bray",
Age = 34,
Country = "US"
}
};
List<string> namesOnly = persons.Where(x => x.Name.Length >= 12).OrderBy(x => x.Name).Take(3).Skip(5).Select(x => x.Name).ToList(); 
