LINQ in C# explained with examples for beginners

What is LINQ in C#? Explained with Examples

Leave a Comment / .NET / By

Working with data in C# can often feel repetitive writing loops to search, filter, or sort collections takes time and makes your code longer than necessary. This is where LINQ in C# becomes a game-changer.

LINQ, short for Language Integrated Query, One of the most powerful features of LINQ is that it works with different data sources, including arrays, lists, XML, and databases using Entity Framework Core. This means you can use the same approach to handle almost any type of data in your applications.

Throughout this guide, you will see how LINQ in C# works. You’ll learn the main syntax options and see practical examples that you can apply in real projects right away.

We Covered given points in this guide:

  • Why LINQ is Important in C#
  • LINQ Syntax in C#: Query vs Method
  • LINQ Examples for Beginners, including: LINQ Select Example, LINQ Where Example, LINQ GroupBy Example
  • LINQ with Entity Framework Core, including: Simple EF Core Query, LINQ to SQL Translation
  • Common LINQ Mistakes and Best Practices, including: Avoid Multiple Enumerations, Null Reference Handling

Why LINQ is Important in C#

LINQ in C# is a powerful feature that makes working with data much easier and faster. Without it, you would often write long loops or multiple lines of code just to filter, sort, or search data.

These points highlight the advantages of using LINQ in C# in your projects

  • Readable and concise code: Perform complex data operations in a single line.
  • Consistency: Works the same with lists, arrays, or databases using Entity Framework Core.
  • Fewer errors: Reduces mistakes from manual loops.
  • Integration: Widely used in APIs(Learn what Web API is in .NET) and modern .NET projects.
  • Easy to maintain: Cleaner code makes updates and debugging simpler.

Tip: Learning LINQ in C# can save you time, make your code cleaner, and help you write professional applications faster.

Before learning LINQ, it’s helpful to understand concepts like Dependency Injection in ASP.NET Core.

LINQ Syntax in C#: Query vs Method

LINQ in C# provides two ways to write queries: query syntax and method syntax. Both do the same work, but the style and readability are slightly different. Knowing both helps you choose the best approach for your code.

1. Query Syntax

Query syntax looks similar to SQL, which makes it easier to read for those familiar with databases. It’s written using keywords like from, where, and select.

Example:

int[] numbers = { 1, 2, 3, 4, 5, 6 };

// Using query syntax to get even numbers
var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

foreach (var n in evenNumbers)
{
    Console.WriteLine(n);
}

Explanation:

  • from num in numbers → selects each number in the array
  • where num % 2 == 0 → filters only even numbers
  • select num → chooses the result to return

2. Method Syntax

Method syntax uses extension methods and lambda expressions, which is very common in modern C# code.

Example:

int[] numbers = { 1, 2, 3, 4, 5, 6 };

// Using method syntax to get even numbers
var evenNumbers = numbers.Where(num => num % 2 == 0);

foreach (var n in evenNumbers)
{
    Console.WriteLine(n);
}

Explanation:

  • Where(num => num % 2 == 0) → filters numbers using a lambda expression
  • Method syntax is shorter and often preferred for chaining multiple operations

Key Differences

FeatureQuery SyntaxMethod Syntax
Style
Similar to SQL
Uses methods and lambdas
Readability
Easier for SQL users
More compact, modern style
ChainingHarder for multiple opsEasy to chain multiple queries
PopularityLess common in modern C#Widely used in real projects

LINQ Examples for Beginners

LINQ in C# makes working with data simple. Instead of writing long loops, you can perform tasks like selecting, filtering, and grouping data in just a few lines.

Here we are see some basic examples

1. LINQ Select Example – Choosing data from a collection

The Select method allows you to pick certain values from a list or array.

string[] fruits = { "Apple", "Banana", "Orange" };

// Get the length of each fruit name
var lengths = fruits.Select(f => f.Length);

foreach (var len in lengths)
{
    Console.WriteLine(len);
}

What happens:

  • Select(f => f.Length) → picks the length of each fruit name
  • Result: 5, 6, 6 (lengths of Apple, Banana, Orange)

2. LINQ Where Example – Filtering data

The Where method helps you filter a collection based on a condition.

int[] numbers = { 1, 2, 3, 4, 5, 6 };

// Get only even numbers
var evenNumbers = numbers.Where(n => n % 2 == 0);

foreach (var n in evenNumbers)
{
    Console.WriteLine(n);
}

What happens:

  • Where(n => n % 2 == 0) → keeps only numbers divisible by 2
  • Result: 2, 4, 6

3. LINQ GroupBy Example – Grouping data

The GroupBy method groups data based on a key.

string[] names = { "Alice", "Bob", "Charlie", "Anna" };

// Group names by the first letter
var groupedNames = names.GroupBy(n => n[0]);

foreach (var group in groupedNames)
{
    Console.WriteLine($"Names starting with {group.Key}:");
    foreach (var name in group)
    {
        Console.WriteLine(name);
    }
}

What happens:

  • GroupBy(n => n[0]) → groups names by the first letter
  • Result:
Names starting with A:
Alice
Anna
Names starting with B:
Bob
Names starting with C:
Charlie

LINQ with Entity Framework Core

When you use LINQ in C# with Entity Framework Core, especially when building CRUD APIs or using Repository Pattern. you write conditions in your code, and only the matching records are returned from your data store.

Example: Students Above 40 Marks

using (var context = new SchoolDbContext())
{
    var result = context.Students
                        .Where(x => x.Marks > 40)
                        .ToList();

    foreach (var item in result)
    {
        Console.WriteLine(item.Name);
    }
}

What this line means (simple view)

  • context.Students → student data source
  • Where(x => x.Marks > 40) → keeps entries where marks are above 40
  • ToList() → turns the result into a usable list

LINQ to SQL Translation

When this LINQ query runs, Entity Framework Core converts it into a SQL query that the database can understand. For this example, it would look similar to:

SELECT * FROM Students WHERE Marks > 40;

This shows how LINQ instructions in C# are translated into database queries, so you can work entirely in C# without writing SQL manually.

Understanding how LINQ converts to SQL is important for performance (read performance optimization guide)

How it behaves when running

This code does not pull data at the moment you write the condition.

The actual reading happens only when you use the result (for example, with ToList() or a loop). At that time, only the matching rows are returned and stored in your variable.

Quick summary

  • LINQ methods like Where work with database data via Entity Framework Core
  • You write conditions in C# instead of SQL
  • Data is fetched only when needed
  • Results behave like normal C# objects

Common LINQ Mistakes and Best Practices

LINQ is very useful, but small mistakes can make your program slower or cause errors. Let’s see a few common ones and how to fix them.

Running the Same Query Again and Again

Sometimes you use the same LINQ query multiple times without realizing it.
Each time you use it, the query runs again which can slow things down.

Example (problem):

var numbers = Enumerable.Range(1, 5).Where(n => n % 2 == 0);

foreach (var n in numbers)
    Console.WriteLine(n);

foreach (var n in numbers)
    Console.WriteLine(n);

Here, the query runs twice.

Better approach:

var numbersList = numbers.ToList(); // runs once

foreach (var n in numbersList)
    Console.WriteLine(n);

foreach (var n in numbersList)
    Console.WriteLine(n);

2. Not Checking for Null

If your data is null, LINQ will throw an error when you try to use it.

Example (problem):

List<string> names = null;

var result = names.Where(n => n.StartsWith("A"));

Safer way:

var result = names?.Where(n => n.StartsWith("A")) ?? new List<string>();

This avoids crashes if names is empty or null.

3. Loading More Data Than Needed

When working with a database, don’t load everything if you only need a small part.

Not a good idea:

var users = context.Users.ToList();

Better:

var userNames = context.Users
                       .Select(u => u.Name)
                       .ToList();

This only gets what you actually need, so it’s faster.

4. Mixing Different LINQ Styles

LINQ has two styles:

  • Method style (Where, Select)
  • Query style (from ... in ... select)

Both work fine, but switching between them randomly can confuse readers.

Pick one style and stick with it.

Quick Tips to Remember

  • Don’t run the same query multiple times
  • Always check for null values
  • Only fetch the data you need
  • Keep your coding style consistent

For better performance, you can also use caching in ASP.NET Core.

Conclusion

LINQ in C# helps you work with data in a much simpler and cleaner way. Instead of writing long and complicated code, you can use easy-to-read statements to filter, select, and organize your data.

In this guide, you learned how LINQ works with collections, the different ways to write it, and how it can be used with Entity Framework Core to handle database data.

The best way to really understand LINQ is by practicing. Start with small examples, try it in your own projects, and slowly you’ll get comfortable with it. Over time, writing LINQ queries will feel natural, and your code will become shorter and easier to read.

Related Articles

Leave a Comment

Your email address will not be published. Required fields are marked *