Introduction to LINQ in .NET

Today, we’re embarking on a new journey — a series on Language Integrated Query (LINQ) in .NET. Whether you’re new to .NET or looking to deepen your understanding, this series aims to guide you through the basics to advanced concepts of LINQ, a powerful feature for querying and manipulating data in .NET applications.

LINQ is ubiquitous in .NET codebases. It’s one of the early features of the C# language and made its initial appearance all the way back in 2007 with the release of C# 3.0 and instantly became a hit! Many C# developers consider C# 3.0 as the pivotal release in the history of C# and a lot of that is due to the immense popularity of LINQ.

What is LINQ?

LINQ (Language Integrated Query) is a set of methods and syntactic sugar in .NET that provides a consistent way to query data from various sources. It integrates querying capabilities directly into the C# language, allowing developers to write queries directly within their code. When we hear queries, our minds may immediately think of SQL or database querying. While LINQ is certainly useful in that aspect, it is much more than just that! Any data source – an array, a list, a collection, an XML file, an object, what have you — can be queried, filtered, manipulated using this powerful construct.

Why LINQ?

LINQ simplifies and unifies the way you query different types of data sources:

• Consistency: Same syntax and concepts across different data sources.
• Readability: Queries are easier to read and understand.
• Productivity: Reduces the amount of boilerplate code.
• Type Safety: Queries are checked at compile time.

Overview of the Series

In this series, we’ll cover everything from basic LINQ queries to advanced concepts. By the end of this series, you should feel comfortable using LINQ in your .NET applications and understand how it can simplify data manipulation and querying.

Basic Syntax and Structure

Before diving into examples, let’s understand the basic syntax and structure of a LINQ query.

A LINQ query typically involves the following steps:

1. Data Source: The data you want to query.
2. Query Definition: The LINQ query expression.
3. Query Execution: Execution of the query to retrieve the results.

Here is a simple example to illustrate:

// Data source
List<int> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Query definition
var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

// Query execution
foreach (var num in evenNumbers)
    Console.WriteLine(num);

In this example:

• Data Source: numbers list.
• Query Definition: LINQ query to select even numbers.
• Query Execution: Iterating over the result to print even numbers.

Detailed Breakdown

1. Data Source: LINQ can query various data sources including collections (like lists and arrays), databases, XML documents, and more. In the example, our data source is a List<int>.
2. Query Definition: The query is defined using the from, where, and select keywords. This syntax is similar to SQL but integrated into C#.
   • from: Specifies the data source and range variable (num in the example).
   • where: Filters elements based on a condition (num % 2 == 0 for even numbers).
   • select: Specifies the result of the query (selects num).
3. Query Execution: The query is executed when iterated over using a foreach loop. LINQ queries use deferred execution, meaning the query is not executed until you iterate over the results.

LINQ Query Syntax

LINQ queries can be written in two main syntaxes: query syntax and method syntax.

Query Syntax: Resembles SQL and uses keywords like from, where, select.

var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

Method Syntax: Uses method calls and lambda expressions.

var evenNumbers = numbers.Where(num => num % 2 == 0).Select(num => num);

Both syntaxes are equivalent and can be used interchangeably. Method syntax is more common in practice (and my personal preference), especially for complex queries.

Another Example

Let’s look at another example where we filter and sort a list of objects.

// Data source
List<Student> students =
    [new Student("Alice", 23),
    new Student("Bob", 17),
    new Student("Charlie", 25),
    new Student("David", 16)];

// Query definition
var minors = students.Where(student => student.Age < 18)
    .OrderBy(student => student.Name);

// Query execution
foreach (var student in minors)
    Console.WriteLine($"{student.Name}, Age: {student.Age}");

// Student "class" definition
public record Student(string Name, int Age);

In this example, we:

• Define a Student record with Name and Age properties.
• Create a list of Student objects.
• Write a LINQ query to filter students younger than 18 and order them by name.
• Execute the query and print the results.

Closing Thoughts

In this introductory post, we covered basic syntax, query structure, and practical examples. In the next part of this series, we will dive deeper into getting started with LINQ, setting up your environment, and writing basic queries. Stay tuned.