C#

What is LINQ?

LINQ stands for Language Integrated Query.Before LINQ developers have to use different technologies when working with different data sources.
For example to query databases developers have to use SQL.To query XML they need to use XPath.LINQ enables us to use the same language which we use to develop our application ,to query data sources.
We can use C# or VB.NET to query different data sources such as in memory collections ,databases,XML or any other data source.

What are data providers?

Data providers allows us to query different data sources using LINQ.There are different data providers for different data sources such as:

• LINQ to Objects
• LINQ to SQL
• LINQ to XML
• LINQ to ADO.NET

LINQ providers converts the LINQ queries to the queries which specific data source understands.

What are query expressions?

Query expressions are used to write LINQ queries in similar way we write SQL queries.Below is a simple query expression:

IEnumerable<int> result = from item in listItmes
where item.name > "TV"
select item.price;

The above query finds the price of the product “TV”.

What are the advantages of LINQ?

• It allows to write query using the same language we use to develop application
• It allows to find errors at compile time
• LINQ can be used to query any data source for which LINQ provider exists.

What is Lambda expression?

Lambda expression is like anonymous function.It does not not have a body and return type.It can assigned to a delegate.We use lambda expression in LINQ to assign it to a delegate.

It has the following form:

input arguments=>body

we can assign a lambda expression to a delegate which returns int as:

delegateMult del= x => x * x;

we can call above delegate as:
del(10);

LINQ components?

What are some LINQ providers?

• LINQ to Objects
• LINQ to SQL
• LINQ to XML
• LINQ to JSON
• LINQ to Sharepoint

LINQ components?

LINQ providers
Query operators
Language extensions

Which namespace defines LINQ extension methods?

System.Linq

What are extension methods?

Extension methods allows us to add new methods to an existing type.When we use extension methods we add new methods without modifying the existing type.

Follow on:

LINQ provides us operator for different tasks such as selection,filtering,ordering.Usually we filter and select the same type as the original type when working with LINQ.

In many scenarios we want to filter and map items to a different list type.For example we are performing LINQ operations on a list of type Product and we want to add the filtered products to a list of string.

In the following example we have a list of Product.We are filtering the items in Product list.We are filtering the items whose price is more than 50.We are using the x => x.Price > 50 lambda expression for this.

Where(x => x.Price > 50)

After we filter the items we are adding the string elements to a list of string type

string.Format("Id: {0} Name: {1} Price: {2}", x.Id, x.Name, x.Price)

Below is the complete example

List<Product> products = new List<Product>();

products.AddRange(new List<Product>{
new Product { Id = 1, Name = "Headset", Price = 100 },
new Product { Id = 2, Name = "Mic", Price = 50 },
new Product { Id = 3, Name = "TV", Price = 1000 }
}
);

List<string> lstProducts = new List<string>();
products.Where(x => x.Price > 50).Select(x => x).ToList().ForEach(x => { lstProducts.Add(string.Format("Id: {0} Name: {1} Price: {2}", x.Id, x.Name, x.Price)); });

foreach(var product in lstProducts)
{
Console.WriteLine(product);
}

Console.ReadLine();

Output:

Follow on:

System.Linq namespace defines many useful extension methods.Following extension methods are used to return single value from the collection.

• FirstOrDefault
• SingleOrDefault

FirstOrDefault

FirstOrDefault is an extension method defined in the System.Linq namespace.It can be called byt the collections implementing IEnumerable.It returns the default value for the type if the collection doesn’t contain any elements.If the collection contains elements than it returns the first element of the collection.

For example if we declare the collection as:

int[] items = {1,2,3,4,5 };
int returnValue = items.FirstOrDefault();


the returnValue will contain the value 1.Since the collection consists of multilple items it returns the first element
which is 1.

On the other hand if declare the collection as:
int[] items = {};
int returnValue = items.FirstOrDefault();

Since the collection doesn’t contain any items it returns the default value for integer which is 0.
So the returnValue will contain the value 0.

Default value to return for the type is determined by the method default(T).

SingleOrDefault

SingleOrDefault returns a single item from the collection if one element exists for the condition.If more than one element exists for the condition than exception is thrown.
List<int> items = new List<int> { 1,2,3,4,5 };
items.SingleOrDefault(item => item ==1);//returns 1
items.SingleOrDefault(item => item ==0);//returns 0 default value for integer
items.SingleOrDefault();//throws exception

In the above SingleOrDefault method calls, the last call throws exception.Since the items collection consists of more than one elements so the method call returns exception.

First

First returns first matching element from a collection if collection consists of more than one matching elements.

List<int> items = new List<int> { 1,2,3,4,5 };
List<int> itemEmpty = new List<int> {};
items.First(item => item >0);//returns 1 ,first element
itemEmpty.First();//returns exception

The First(item => item >0) method call above returns 1 ,since there are multiple matching elements.The second method call throws exception since the collection doesn’t
contain any elements.

Single

Single returns element if a single matching element is found.If more than one element are found or no element is found than exception is thrown.

Follow on:

There are two ways in which we can execute the LINQ queries ,Immediate and Deferred .Immediate and Deferred query execution in LINQ means when the query is executed.This is because the query declaration in LINQ is different from query execution.

When we write a LINQ query we declare a query variable which contains the result of the LINQ query.
Usually we declare a query variable using var type as:

var results= from student in students
where student.class == 12
select student

The above result variable contains the result of the query execution.

You may think that by just declaring the query above ,the result variable will contain the list of students of class
12th.This doesn’t happen.

results variable will not contain the result of query execution until we loop or iterate over the query variable.

class Student
{
public string Name { get; set; }
public string Subject { get; set; }
public int Marks { get; set; }

public int Class { get; set; }
}
var students=new List<Student>{
new Student{Name="Amit",Class=12},
new Student{Name="John",Class=10},
new Student{Name="Raj",Class=8},
new Student{Name="Greg",Class=12},
new Student{Name="Priya",Class=12},
};

var results = from student in students
where student.Class == 12
select student;

Following iteration executes the query referred by the query variable.

foreach(var student in results)
{
Console.WriteLine(student);
}

This is called deferred query execution

If we want to immediately execute the query we can do so.Immediately query execution will immediately execute the query as soon as we assign the query to the query variable.
We can immediately execute the query by any of the following ways

1.By calling aggregate method such as count.We use this when we need to retrieve a single value such as count of the elements contained in the results collection.

var results = (from student in students
where student.Class == 12
select student).Count();

2.By calling the collection methods such as ToList().We use this when we need to convert the results variable to list value such as count of the elements contained in the results collection.

var results = (from student in students
where student.Class == 12
select student).ToList();

 

Follow on: