Conversion Operators in LINQ

The following are the conversion operators in LINQ:

• ToList
• ToArray
• ToDictionary
• ToLookup
• Cast
• OfType
• AsEnumerable

But before going into any further details, we must learn what Deferred and Immediate Execution is.

LINQ operators can be categorized into the following.

Deferred or lazy operators: For example Select, Where, Take, Skip and so on.

Immediate operators: For example Count, Max, Min, Average, ToList and so on.

Let's look at an example of deferred execution.

using System;
using System.Collections.Generic;
using System.Linq;
namespace DeferredAndImmediate
{
    class Employee
    {
        public int Id{get;set;}
        public string Name {get;set;}
        public double Salary{get;set;}
    }
    class Program
    {
        static void Main(string[] args)
        {
            List < Employee > EmployeeList = new List < Employee > ()
            {
                new Employee()
                {
                    Id = 1, Name = "Sam", Salary = 41000
                },
                new Employee()
                {
                    Id = 2, Name = "Max", Salary = 41000
                },
                new Employee()
                {
                    Id = 3, Name = "Sara", Salary = 21000
                }
            };
        }
    }
}

Currently in my project I have a class “Employee” with three auto-implemented properties.

In the main method there is a list of employees.

Now let's say we want the records of all the employees whose salary is 41000.

IEnumerable<Employee> employees = from employee in EmployeeList
where employee.Salary == 41000
select employee;

To loop thru each employee we can use a foreach loop.

foreach(Employee emp in employees)
{
Console.WriteLine(emp.Name);
}

Now before running this application, let's understand where this program actually executes. What I am trying to say here is this program executes here.

IEnumerable<Employee> employees = from employee in EmployeeList
where employee.Salary == 41000
select employee;
Or during the foreach loop.
foreach(Employee emp in employees)
{
Console.WriteLine(emp.Name);
}

This program actually executes during the foreach loop and to prove that let's add another employee item to the list.



Run the application.



In the output we get three records which means the preceding query executes during the foreach loop that states this a deferred execution.

Now let's look at an example of immediate execution.

IEnumerable<Employee> employees = (from employee in EmployeeList
where employee.Salary== 41000
select employee).ToList();
Convert the above linq query to a list.
EmployeeList.Add(new Employee() { Id = 4, Name = "Aiden", Salary = 41000 });
foreach(Employee emp in employees)
{
Console.WriteLine(emp.Name);
}

Run the application.



This time we got two records which means this ToList is an immediate execution operator.

Just like that count, max, min are immediate execution operators.

So, we now have some basic understanding of Deferred and Immediate execution. Let's dive right back to the conversion operator.

ToList

The ToList operator extracts items from the sequence and returns a new list back. This operator uses immediate execution.

DEMO

static void Main(string[] args) {#region ToList
    //create array of integers
    int[] numbers =
    {
        1, 2, 3, 4, 5
    };
    //convert array to list which will return list of integers
    List < int > listNumber = numbers.ToList();
    //loop thru each list item
    foreach(int item in listNumber)
    {
        Console.WriteLine(item);
    }#endregion
}

Run the application.



ToArray

This operator extracts items from a sequence and returns a new array. This operator causes immediate execution.

DEMO

#region ToArray
//create a list of string
List < string > BrandList = new List < string > () {
    "Apple", "Microsoft", "Google", "Samsung", "Sony"
};
//retrieve items from the list in ascending order and convert them to array
string[] brandArray = (from brand in BrandList
orderby brand ascending
select brand).ToArray();
foreach(string item in brandArray)
{
    Console.WriteLine(item);
}#endregion

ToDictionary

The ToDictionary operator executes the query, retrieves items from the sequence and returns a new dictionary object back. This operator is an immediate execution operator.

DEMO

class Employee
{
    public int Id
    {get;set;}
    public string Name
    {get;set;}
    public double Salary
    {get;set;}
}
class Program
{
    static void Main(string[] args) {#region ToDictionary
        List < Employee > employeeList = new List < Employee > ()
        {
            new Employee()
            {
                Id = 1, Name = "Sara", Salary = 41000
            },
            new Employee()
            {
                Id = 2, Name = "Sam", Salary = 11000
            },
            new Employee()
            {
                Id = 3, Name = "Aiden", Salary = 21000
            }
        };

        Dictionary < int, Employee > employeeDic = employeeList.ToDictionary(x = > x.Id, y = > y);
        foreach(KeyValuePair < int, Employee > employee in employeeDic)
        {
            Console.WriteLine(employee.Key);
            Console.WriteLine(employee.Value.Name);
        }#endregion
    }
}

Run the application.



ToLookup

Just like a dictionary, a Lookup is a collection of key/value pairs. The only difference between the two is a dictionary cannot contain keys with identical values whereas a lookup can.

DEMO

class Employee
{
    public string Name
    {get;set;}
    public string JobTitle
    {get;set;}
    public string City
    {get;set;}
}
static void Main(string[] args) {#region ToLookup
    //create a list of employees
    List < Employee > employeeList = new List < Employee > ()
    {
        new Employee()
        {
            Name = "Aiden", JobTitle = "Sr. Developer", City = "London"
        },
        new Employee()
        {
            Name = "Max", JobTitle = "Developer", City = "Bangalore"
        },
        new Employee()
        {
            Name = "Sara", JobTitle = "Developer", City = "Bangalore"
        },
        new Employee()
        {
            Name = "Lara", JobTitle = "Sr. Developer", City = "London"
        },
        new Employee()
        {
            Name = "Michael", JobTitle = "Developer", City = "London"
        },
        new Employee()
        {
            Name = "Sam", JobTitle = "Developer", City = "London"
        }
    };
    //pass JobTitle as a key in the ToLookup method
    ILookup < string, Employee > employeeLookup = employeeList.ToLookup(x = > x.JobTitle);
    Console.WriteLine("Employee grouped by JobTitle");
    Console.WriteLine();
    //loop thru each items in employeelookup which will give IGrouping of key and value
    foreach(IGrouping < string, Employee > kvp in employeeLookup)
    {
        //print the key
        Console.WriteLine(kvp.Key);
        //add another foreach loop, using the key look for the items. This will return employee object back
        foreach(Employee emp in employeeLookup[kvp.Key])
        {
            Console.WriteLine("\t" + emp.Name + "\t" + emp.City);
        }
        Console.WriteLine();
    }#endregion
}
}

Run the application.



Just like that we can even group them by city.

ILookup < string, Employee > employeeLookup = employeeList.ToLookup(x = > x.City);
Console.WriteLine("Employee grouped by JobTitle");
Console.WriteLine();
foreach(IGrouping < string, Employee > kvp in employeeLookup)
{
    Console.WriteLine(kvp.Key);
    foreach(Employee emp in employeeLookup[kvp.Key])
    {
        Console.WriteLine("\t" + emp.Name + "\t" + emp.JobTitle);
    }
    Console.WriteLine();
}

Run the application.



Cast

The Cast operator attempts to convert all the items within a collection to another type and return them in a new collection. If an item fails to convert then an exception is thrown. This cast method or operator uses deferred execution.

DEMO

ArrayList al = new ArrayList();
al.Add(2);
al.Add(4);
al.Add(6);
al.Add(8);
IEnumerable<int> numbers = al.Cast<int>();
foreach(int item in numbers)
 {
Console.WriteLine(item);
}

In the preceding demo, we creates an arraylist and this arraylist expects an item of type object.

Then using the cast operator we type-casted this arraylist object to an integer.

Run the application.



Let's add a new item to the same arraylist as in the following:

al.Add("9");

Run the application.



The first four numbers were printed but the fifth item throws an exception since this fifth item is of type string and the cast operator was not able to cast it into an integer.

So, always use this cast operator where a collection item will return a specified data type.

ofType

The OfType operator will only return the items of the specified type and other items will be excluded from the result set. This OfType uses deferred execution.

Demo

ArrayList al = new ArrayList();
al.Add(2);
al.Add(4);
al.Add(6);
al.Add(8);
al.Add("9");
IEnumerable<int> numbers = al.OfType<int>();
foreach(int item in numbers)
{
Console.WriteLine(item);
}

In the preceding demo we have a arraylist in which we have four integer items and one string item.

Run the application.



We got only the integer value back because this OfType operator will always return only the specified data type items back.

AsEnumerable

Use the AsEnumerable operator to move query processing to the client side.

This AsEnumerable operator breaks the query into the following two parts: 

1. The first is the inside part in other words before AsEnumerable that gets executed as LINQ to SQL.
2. The second is the outside part in other words after AsEnumerable that gets executed as LINQ to Objects.

Let's look at an example.

For the demo we will be using the following table.



Query for this table

CREATE DATABASE db_AsQueryable
GO
USE db_AsQueryable
Create Table Employees
(
ID int primary key identity,
Name nvarchar(50),
Gender nvarchar(50),
Salary int
)
GO
Insert into Employees Values('Mark','Male','60000')
Insert into Employees Values('Steve','Male','45000')
Insert into Employees Values('Ben','Male','70000')
Insert into Employees Values('Philip','Male','45000')
Insert into Employees Values('Mary','Female','30000')
Insert into Employees Values('Valarie','Female','35000')
Insert into Employees Values('John','Male','80000')
Insert into Employees Values('Pam','Female','85000')
Insert into Employees Values('Stacey','Female','65000')
Insert into Employees Values('Andy','Male','73000')
Insert into Employees Values('Edward','Male','65000')
GO

Step 1

Add a LINQ to SQL data model.



Click Add

Navigate to server explorer from view and click on connect to database.

Specify the server name and database.



Drag and drop the table to the designer window.



Step 2

In the main method of your project add the following.

EmployeeDBDataContext employee = new EmployeeDBDataContext();
var emp = employee.Employees.Where(x => x.Gender == "Male").OrderByDescending(x => x.Salary).Take(5);
foreach(var item in emp)
{
Console.WriteLine(item.Name + "\t" + item.Gender + "\t" + item.Salary);
}

Step 3

Open SQL Server -> open SQL Server profiler then run the console application.



In the SQL Server profiler look at the codes that got generated that executes and gave us the result.



Now just after the employees property and before the where operator invoke the AsEnumerable operator and re-run the application.

var emp = employee.Employees.AsEnumerable().Where(x => x.Gender == "Male").OrderByDescending(x => x.Salary).Take(5);

The output will remain the same.



But in the SQL Server profiler look at the code that was generated.



As very simple select statement and there are nowhere, orderby and top clause.The reason is that this AsEnuermable operator divides the query into two parts. One is the internal part that is before the AsEnumerable is executed using LINQ to SQL whereas the outer part is executed using the LINQ to object client-side memory datasets.

I hope you like it.

Thank you.