Querying with LINQ


LINQ (Language Integrated Query) is a powerful feature in C# that allows developers to query data from various data sources in a unified way. LINQ to SQL and Entity Framework are two popular ORM (Object-Relational Mapping) frameworks in .NET that enable developers to interact with databases using LINQ.

How LINQ is used to query databases using LINQ to SQL or Entity Framework?

Here's a brief explanation of how LINQ can be used to query databases using LINQ to SQL or Entity Framework.

1. Define Data Model: In both LINQ to SQL and Entity Framework, you start by defining your data model using classes. These classes represent tables in your database, and the properties of these classes represent columns.

2. Create DataContext or DbContext: In LINQ to SQL, you create a DataContext class that represents the database connection and acts as a bridge between your application and the database. In Entity Framework, you create a DbContext, which serves a similar purpose.

3. Query Data: Once you have your data model set up, you can use LINQ queries to interact with your data. LINQ provides a set of standard query operators (such as Where, OrderBy, Select, etc.) that can be used to query data in a SQL-like syntax.

For example

// LINQ to SQL
var query = from customer in db.Customers
            where customer.City == "Pune"
            select customer;

// Entity Framework
var query = dbContext.Customers.Where(customer => customer.City == "Pune");

4. Execute Queries: After constructing your LINQ query, you can execute it to retrieve data from the database. Depending on the scenario, you can execute the query immediately to retrieve a collection of objects or defer execution until later.

5. Handle Results: Once the query is executed, you can handle the results just like any other collection in C#. You can iterate over the results, perform further processing, or bind them to UI elements.

6. CRUD Operations: LINQ to SQL and Entity Framework also support CRUD (Create, Read, Update, Delete) operations. You can use LINQ queries to insert, update, and delete records in the database.

Overall, LINQ provides a convenient and expressive way to interact with databases.

LINQ queries into SQL queries, making it easier for developers to work with databases without needing to write raw SQL.

Syntax and usage of LINQ queries in C#

1. LINQ Query Syntax

The query syntax in LINQ resembles SQL syntax. It consists of three main clauses: from, where, and select.

var query = from item in collection
            where condition
            select item;
  • from: Specifies the data source and the range variable (item) to represent each element in the data source.
  • where: Filters the elements based on a specified condition.
  • select: Projects each element of the filtered sequence into a new form.

2. LINQ Method Syntax

Alternatively, LINQ queries can be written using method syntax.

var query = collection
            .Where(item => condition)
            .Select(item => item);
  • Where: Filters elements based on a specified condition.
  • Select: Projects each element of a sequence into a new form.

3. Supported Operations

LINQ supports various operations like filtering (Where), projection (Select), ordering (OrderBy, OrderByDescending), grouping (GroupBy), joining (Join, GroupJoin), aggregation (Count, Sum, Average, Min, Max), and more.

4. Querying Different Data Sources

LINQ can be used to query different types of data sources including in-memory collections (such as arrays, lists), databases (using LINQ to SQL or Entity Framework), XML, JSON, and more.

LINQ provides a powerful and concise way to query and manipulate data in C# applications, making code more readable and maintainable. Whether you're working with collections in memory or querying databases, LINQ offers a unified and expressive syntax for data manipulation.

Let's explore some of the most commonly used LINQ operators with examples:


Filters a sequence based on a specified condition.

// Example with an array of integers
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbers = numbers.Where(x => x % 2 == 0);
// Output: 2, 4, 6, 8, 10


Projects each element of a sequence into a new form.

// Example with an array of strings
string[] fruits = { "apple", "banana", "orange", "kiwi" };
var capitalizedFruits = fruits.Select(fruit => fruit.ToUpper());
// Output: "APPLE", "BANANA", "ORANGE", "KIWI"

OrderBy / OrderByDescending

Sorts the elements of a sequence in ascending or descending order based on a key.

// Example with a list of persons
List<Person> persons = GetPersons(); // Assume a list of Person objects
var orderedPersons = persons.OrderBy(person => person.LastName);
// or
var orderedPersonsDescending = persons.OrderByDescending(person => person.Age);


Groups elements of a sequence based on a key.

// Example with a list of persons grouped by their age
var groupedPersons = persons.GroupBy(person => person.Age);
foreach (var group in groupedPersons)
    Console.WriteLine($"Age: {group.Key}");
    foreach (var person in group)
        Console.WriteLine($" - {person.FirstName} {person.LastName}");


Joins two sequences based on a common key.

// Example joining a list of persons with a list of cities they live in
var query = from person in persons
            join city in cities on person.CityId equals city.Id
            select new { person.FirstName, person.LastName, city.Name };

These are just a few examples of LINQ operators, but there are many more available for various types of data manipulation and querying tasks.