Linq To Objects | Linq | Csharp Tutorial

Introduction to LINQ to Objects

LINQ (Language Integrated Query) is a powerful feature in C# that allows you to work with data in a more readable and concise way. LINQ to Objects specifically refers to the use of LINQ queries with in-memory collections such as arrays, lists, and other collections that implement the IEnumerable<T> interface.

Setting Up the Environment

Before you start using LINQ to Objects, ensure you have the following:

Visual Studio or any C# compiler
.NET Framework or .NET Core

Here is an example of a simple C# program setup:

using System;
using System.Collections.Generic;
using System.Linq;

namespace LINQToObjectsTutorial
{
    class Program
    {
        static void Main(string[] args)
        {
            // Your code here
        }
    }
}

Basic LINQ Query Syntax

LINQ queries can be written in two syntaxes: query syntax and method syntax. Here is an example of both:

Query Syntax:

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

Method Syntax:

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(num => num % 2 == 0);

Filtering Data

Filtering data in LINQ is done using the where clause. This allows you to specify a condition that the data must meet to be included in the result.

var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbers = numbers.Where(n => n % 2 == 0);

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

2
4
6
8
10

Projecting Data

Projection operations in LINQ allow you to transform the data in your collection. This is typically done using the select clause.

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var squares = numbers.Select(n => n * n);

foreach (var square in squares)
{
    Console.WriteLine(square);
}

1
4
9
16
25

Ordering Data

LINQ provides methods to order data in a collection. You can use the OrderBy and OrderByDescending methods to sort data in ascending and descending order, respectively.

var numbers = new List<int> { 5, 1, 4, 2, 3 };
var sortedNumbers = numbers.OrderBy(n => n);

foreach (var num in sortedNumbers)
{
    Console.WriteLine(num);
}

1
2
3
4
5

Grouping Data

Grouping in LINQ is performed using the group clause. This allows you to group data based on a specified key.

var words = new List<string> { "apple", "banana", "apricot", "blueberry" };
var wordGroups = from word in words
                 group word by word[0];

foreach (var group in wordGroups)
{
    Console.WriteLine($"Words that start with {group.Key}:");
    foreach (var word in group)
    {
        Console.WriteLine(word);
    }
}

Words that start with a:
apple
apricot
Words that start with b:
banana
blueberry

Joining Data

Joining operations in LINQ are used to combine data from different sources based on a common key. The join clause is used for this purpose.

var students = new List<Student> {
    new Student { Id = 1, Name = "John" },
    new Student { Id = 2, Name = "Jane" }
};

var scores = new List<Score> {
    new Score { StudentId = 1, Value = 90 },
    new Score { StudentId = 2, Value = 80 }
};

var studentScores = from student in students
                    join score in scores on student.Id equals score.StudentId
                    select new { student.Name, score.Value };

foreach (var item in studentScores)
{
    Console.WriteLine($"{item.Name}: {item.Value}");
}

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Score
{
    public int StudentId { get; set; }
    public int Value { get; set; }
}

John: 90
Jane: 80

Aggregating Data

Aggregation operations in LINQ, such as Count, Sum, Min, Max, and Average, allow you to perform calculations on collections.

var numbers = new List<int> { 1, 2, 3, 4, 5 };

var sum = numbers.Sum();
var min = numbers.Min();
var max = numbers.Max();
var average = numbers.Average();

Console.WriteLine($"Sum: {sum}");
Console.WriteLine($"Min: {min}");
Console.WriteLine($"Max: {max}");
Console.WriteLine($"Average: {average}");

Sum: 15
Min: 1
Max: 5
Average: 3

Deferred Execution

LINQ queries use deferred execution. This means that the query is not executed when it is defined but rather when it is iterated over.

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);

numbers.Add(6);

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

2
4
6

Conclusion

LINQ to Objects is a powerful feature in C# that allows you to work with in-memory collections in a more readable and concise way. By mastering LINQ, you can significantly simplify your data manipulation code and improve its readability.

LINQ to Objects - Comprehensive Tutorial