> For the complete documentation index, see [llms.txt](https://raviram.gitbook.io/c-programing/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://raviram.gitbook.io/c-programing/linq/introduction.md).

# Introduction

## Introduction

### What is LINQ?

The acronym LINQ stands for Language Integrated Query. LINQ syntax is roughly derived from SQL and was introduced with .NET 3.5

The LINQ paradigm describes a method for programmatically accessing and manipulating any data, **independent of the source**. LINQ integrates query capabilities directly into the C# language. It provides a **consistent** query experience for in-memory objects (LINQ to Objects), relational databases (LINQ to SQL), and XML (LINQ to XML).

### Getting started with basic LINQ queries

#### Query 1: From a give array of strings, below query filters the ones with the letter ‘a’ in it

```csharp
var words = new string[] { "falcon", "eagle", "sky", "tree", "water" };

// Query syntax
var res = from word in words
          where word.Contains('a')
          select word;

foreach (var word in res)
    Console.WriteLine(word);

Console.ReadKey();
```

#### Things to note:

* The above LINQ query is written in what is called as **query syntax**
* The above snippet will not compile without `using System.Linq;` It is the namespace required to use LINQ in .NET framework
* We can use this snippet in any kind of .NET project, like Console, WinForms or Web based projects
* We have used the `var` keyword to hold the results of the query, since it is convenient
* The actual return type would be `IEnumerable<string>`
* The `IEnumerable` interface is **central to LINQ**. We can use LINQ on any object that implements `IEnumerable`
* We can even create our own classes that implements `IEnumerable`, and those classes will instantly "inherit" all LINQ functionality!

We can re-write the same using what is called **method syntax** as shown below

```csharp
var words = new string[] { "falcon", "eagle", "sky", "tree", "water" };

// Method syntax
var res = words.Where(word => word.Contains("a")); //Lambda expression

foreach (var word in res)
    Console.WriteLine(word);

Console.ReadKey();
```

We can **re-write** the same replacing `var` with `IEnumerable` as shown below:

```csharp
var words = new string[] { "falcon", "eagle", "sky", "tree", "water" };

IEnumerable<string> res = words.Where(word => word.Contains("a"));

foreach (var word in res)
    Console.WriteLine(word);

Console.ReadKey();
```

In all cases, the o/p will be

```csharp
falcon
eagle
water
```

#### Query 2: From a given array of integers, below query filters the even ones in it

```csharp
int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9};

var res = nums.Where(n => n % 2 == 0);

foreach (var num in res)
    Console.WriteLine(num);

Console.ReadKey();
```

In the queries above, since we have used LINQ on in-memory objects, we call this mode as **LINQ-To-Objects**. Similarly, we can use LINQ on any other data, be it in the XML form, SQL Data (LINQ-To-SQL) or Entities (LINQ-To-Entities)

### Pros & cons of LINQ

#### Let’s check some advantages of using LINQ:

* Improves code readability&#x20;
* Provides compile-time object type-checking&#x20;
* Provides IntelliSense support for generic collection&#x20;
* LINQ queries can be reused&#x20;
* Provides in-built methods to write less code and expedite development&#x20;
* Provides common query syntax for various data sources

#### There are also disadvantages of using LINQ:

* Difficult to write complex queries as SQL&#x20;
* Performance degradation if queries are not written accurately&#x20;
* Require to recompile, and redeploy every time a change is made to the query
* Doesn’t take full advantage of SQL features such as cached execution plan for stored procedure

### Additional Reading

<https://docs.microsoft.com/en-us/dotnet/standard/linq/>