Introduction:

Welcome to this Blog series on LINQ, where we'll introduce the basics of LINQ and its advantages over traditional programming methods.

What is LINQ?

LINQ stands for Language Integrated Query, which is a set of features that allow you to query data from various data sources.* LINQ queries can be written to work with any collection that implements the IEnumerable<T> interface, such as collections, arrays, databases, XML documents, and more, using a common syntax in C#.

Why use LINQ?

Using LINQ provides several advantages over traditional programming methods like SQL queries or loops. Some of these advantages are:

• LINQ makes querying data easier and more intuitive, reducing the amount of code you need to write.

• LINQ queries are strongly typed, which means that errors can be caught at compile-time instead of run-time.

• LINQ queries can be optimized by the .NET runtime, resulting in faster execution times.

• LINQ code is easier to maintain and modify since it's more readable and easier to understand.

LINQ Query Syntax:

The LINQ query syntax is very similar to SQL syntax. A LINQ query consists of three parts:

1. Data Source: A collection or data source that will be queried.

2. Query Expression: A set of clauses that define what data is retrieved, and how it's filtered and transformed.

3. Query Execution: The code that executes the query and returns the result.

   Let's look at a simple example:

   Example 1: Querying a List Suppose we have a list of integers, and we want to get all the even numbers from the list.

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

namespace LinqExample
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

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

            Console.WriteLine("Even numbers: " + string.Join(", ", evenNumbers));
        }
    }
}

In this example, we create a list of integers and use LINQ to query for only the even numbers. We use the from keyword to specify the collection we want to query (numbers), and then we use the where keyword to specify the condition for filtering (num % 2 == 0), and finally the select keyword to specify which elements we want to include in the result (num).

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;
foreach (var num in evenNumbers)
{
    Console.WriteLine(num);
}

we use the from keyword to specify the data source (the numbers list). We use the where clause to filter the list to only include even numbers, and we use the select clause to project the resulting data. Finally, we iterate through the evenNumbers sequence and print out each number.

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

As you can see, we use the Where extension method to filter the collection based on the specified condition. We also use lambda expressions instead of query expressions to write our LINQ queries.

Using extension methods can sometimes be more concise and easier to read, but both approaches achieve the same result.

Example 2: Querying a Database Now let's look at a more complex example of querying a database using LINQ. Suppose we have a database table called "Customers", and we want to get all the customers who live in a specific city.

using (var dbContext = new CustomerDbContext())
{
    var customers = from c in dbContext.Customers
                    where c.City == "Seattle"
                    select c;

    foreach (var customer in customers)
    {
        Console.WriteLine($"{customer.Name} - {customer.Email}");
    }
}

OR

using (var dbContext = new CustomerDbContext())
{

var customers = dbContext.Customers.Where(cust => cust.City == "Seattle") 

    foreach (var customer in customers)
    {
        Console.WriteLine($"{customer.Name} - {customer.Email}");
    }
}

In the above example, we use the from keyword to specify the data source (the Customers table in the database). We use the where clause to filter the results to only include customers who live in Seattle, and we use the select clause to project the resulting data (in this case, the customer's name and email address). Finally, we iterate through the customers sequence and print out each customer's name and email.

What is the difference between the extension method and normal line query when we should use which one and why?

That's a great question! The main difference between using query syntax and extension method syntax in LINQ is just the syntax used to write the code.

Query syntax uses keywords like from, where, and select to build up a query expression that resembles SQL syntax.

Extension method syntax uses method calls on a collection to build up a query. Both approaches are functionally equivalent and produce the same results.

So, which one should you use? It really comes down to personal preference and readability. Some developers find query syntax to be more readable and easier to understand, especially for more complex queries. Other developers prefer extension method syntax for its conciseness and familiarity with using method calls.

In general, it's a good practice to use the syntax that is most readable and understandable to you and your team. It's also a good idea to be familiar with both approaches so that you can easily read and understand code written in either syntax.

Thats it for this will see you in next stay connected.

Thanks,