Archives for November 2015

Aggregate functions are applied to each element in a sequence and finally returns a single aggregated value.For example sum() function is applied to the first,second element to calculate their sum.This sum is then added to the third element to calculate the sum of first three elements.Finally the total sum of all the elements is calculated and returned.

Some of the aggregate operators are:

• Sum
• Count
• Average
• Min
• Max

Sum    Sum operator is applied to the values in a sequence and calculates a single value which is the sum of all the values in a collection.
In the following example we have a collection of students.Each element in the collection is represented by an object of Student class.

class Student
{
public String Name { get; set; }
public int TotalMarks { get; set; }
//other properties
}

The students are added in the collection:

List<Student> lstStudents = new List<Student>
{
new Student{Name="Marc",TotalMarks=774},
new Student{Name="John",TotalMarks=789},
new Student{Name="Amit",TotalMarks=888},
};

The sum of the scores of all the students can be calculated by using the sum function as:

lstStudents.Sum(x => x.TotalMarks);

We can write the above Sum() operator as:

int sum = lstStudents.Select(x => x.TotalMarks).Sum();

Note that we have passed the lambda expression to the Select() operator instead of Max().We can use the similar method overloads for each of the aggregate operators.

Max      Many times when working with numeric values we need to find the maximum value from a collection of values.Max operator can be used in such a scenario to find the maximum value from a collection of values.Continuing with the example of collection of students ,the student having maximum score can be found as:

int max = lstStudents.Max(x => x.TotalMarks);

Above Max() function can also be written as:

int max= lstStudents.Select(x=>x.TotalMarks).Max();

Min    Sometimes it is required to identify an element having a minimum value in a collection of elements.Min operator is used to find a minimum value from a collection of values.
In the following example we have a collection of days and temperatures.

Dictionary<int, int> tempratures = new Dictionary<int, int>();
tempratures.Add(1, 15);
tempratures.Add(2, 18);
tempratures.Add(3, 20);
tempratures.Add(4, 16);
tempratures.Add(5, 12);
tempratures.Add(6, 19);

tempratures.Add(7, 17);
tempratures.Add(8, 26);
tempratures.Add(9, 16);
tempratures.Add(10, 19);

The minimum temperature can be identified as:

int min=tempratures.Min(x => x.Value);

Average  To calculate the average of numeric values in a collection we can use the Avg operator.
Continuing with the previous example of days and tempratures ,average temprature can be calculated as:

double avg = tempratures.Average(x => x.Value);

Count   This returns the total number of elements in a collection.

Some of the main points about aggregate functions in LINQ are:

• Aggregate queries are executed immediately unlike other operators which are executed when the collection is iterated.
• Aggregate queries typically return a number instead of a collection.

 

Follow on:

LINQ consists of a set of query operators.These query operators transforms a sequence .Sequence is just a collection of objects.Sequences in LINQ are used by the LINQ operators in queries.
There are two sequences which can be used in LINQ queries

• IEnumerable
• IQueryable

LINQ operators can be applied to any collection which implements any of these interfaces.There are lots of collections which implements these types.Some of the common collections which implements these types are

• Array
• Generic list ,List<T>
• LinkedList<T>
• HashSet<T>
• Collection<T>
• Dictionary<TKey,TValue>

The query operators are defined in the System.Linq namespace and are defined as extension methods.So to apply these operators we need to import the System.Linq namespace.

In the following example we are querying an array which contains different weather conditions.We are selecting all the weather conditions which are not equal to “Hot”

string[] weather = { "Hot", "Cool", "Moderate" };
var result=weather.Where(x => x != "Hot").Select(x=>x.ToString());
foreach(var item in result)
Console.WriteLine(item);

The collection weather will contain the values “Cool” and “Moderate”

There are few important things to understand about the above code.Where is a query operator which filters the items in a collection based on a condition

• Select is a query operator which is used for projecting the items in the result collection
• Select returns an object of type IEnumerable<TResult> where TResult represents the type of items in the result collection

So in the above example instead of the following line

var result=weather.Where(x => x != "Hot").Select(x=>x.ToString());

we can use the below

IEnumerable<string> result = weather.Where(x => x != "Hot").Select(x => x.ToString());

IQueryable<T>

Another Sequence in LINQ is IQueryable<T>.Like IEnumerable<T> it is used in LINQ queries. IQueryable<T> implements the IEnumerable<T> interface.
The difference is that IQueryable<T> is used to execute queries remotely.It is used with query providers such as LINQ to SQL.Different query providers can provide their own implementations of IQueryable<T>.

IQueryable<T> constructs queries using expression tree unlike IEnumerable<T> which constructs queries using delegates.Expression tree is used to create an actual query on the remote data source.

AsEnumerable()

The AsEnumerable() method can be called on collections which implements IEnumerable<T>.For example DataTable type in ADO.NET has its own implementation of query operator.By calling AsEnumerable() method on the table we can use the Standard query operators.If we don’t use AsEnumerable() on the DataTable then the custom implementation of the DataTable is used instead.

DataTable table = new DataTable();
table.AsEnumerable().Select(x => x);

 

Follow on:

Let keyword introduces a new range variable in a LINQ query.This range variable stores the result of the sub expression.This variable can be used anywhere in the query ,after it is declared.

This helps keep many complex queries simple.

Using Let keyword in LINQ

Its used as:

sub expression1
let letVariable = query expression which returns a value
sub expression2 which uses the letVariable

In the following example we have declared a generic list of Students.Every student can have one or many subjects.

List<Student> students = new List<Student>
{
new Student{Name="John",Subjects=new List<Subject>{
new Subject{Name="Maths",Marks=90 },
new Subject{Name="English",Marks=70 }
}
},
new Student{Name="Mark",Subjects=new List<Subject>{
new Subject{Name="Maths",Marks=66 },
new Subject{Name="English",Marks=55 }
}
},
new Student{Name="Amit",Subjects=new List<Subject>{
new Subject{Name="Maths",Marks=71 },
new Subject{Name="English",Marks=87 }
}
},
new Student{Name="Laxman",Subjects=new List<Subject>{
new Subject{Name="Maths",Marks=54 },
new Subject{Name="English",Marks=67 }
}
},
};

Now to find the list of all students who scored more than average score in Maths we will have to write complex linq query or use multiple queries.By using the Let clause we can use a single query as:

var result = from student in students
let total = students.Select(x =>
x.Subjects.Where(y => y.Name == "Maths").Select(y => y.Marks).FirstOrDefault()
).Cast<int>().Sum()
let average = total / students.Count()
let markInMaths = (from subject in student.Subjects
where subject.Name == "Maths"
select subject.Marks).FirstOrDefault()
where markInMaths > average
select new { student.Name, markInMaths, average };

In the above query 2 LINQ let clauses are used markInMaths and average.These variables stores the marks in maths for a specific student and average of marks in Maths respectively.

We are using these 2 let variables in the where clause of the outermost query to filter the students

where markInMaths > average

the where clause will filter the list of students who have scored more than average in Maths.

Finally we can print the list of students:

foreach(var student in result)
{
Console.WriteLine("{0},{1},{2}", student.Name, student.markInMaths, student.average);
}

The above statement will print the values for students John and Amit as they have above average marks in Maths.

Using Let keyword in LINQ helps manage complexity of Linq queries and allows to implement complex scenarios.

Follow on:

LINQ allows us to query data in a application using a .NET language such as C# similar to how SQL is used for querying databases.

Introduction to LINQ queries

Linq queries are composed using the query operators.There are many query operators defined in the System.Linq namespace as extension methods.These query operators are defined as extension methods on the Enumerable and Queryable classes.
Query operators defined on the Queryable class are used to execute queries on a remote data source such as SQL Server database whereas the query operators in the Enumerable class are used for executing queries for in memory collections.

The Standard Query Operators are divided into two groups one which operates on a sequence of type  IEnumerable<T> and other which operates on sequence of type  IQueryable<T>.

Some of the most useful query operators are:

from   this clause begins the query and must precede all other clauses such as select and where.the from clause specifies two important aspects of a query.It specifies the source and a range variable which represents each item in the source.It is used as:

var variable=from rangeVariable in Source

The type of the range variable is automatically inferred from the type of elements in the source.So if the source is of type List<Student> then the range variable will be of type Student.

Where   used for filtering a collection based on a condition.The condition which is specified as a predicate is evaluated  against each item in the collection.If the condition returns true then the item is included in the result collection.
The function passed to the Where operator is of the form Func<TSource, bool>.This is a predicate function as it returns a boolean value.A value of true or false is returned which depends on the item in the collection.It is used as:

where boolean condition

The boolean condition above is a predicate which is applied to each element in the data source.If the condition returns true then the element is included in the result.

Select   used for projecting a collection depending on the function passed in to each item of the collection.The function passed to the select operator is of the form Func<TSource, TResult> .This function accepts an input of a specific type and returns the transformed type.It is used as:

var result= from rangeVariable in DataSource
where boolean condition
select rangeVariable.Property

Example of LINQ query

We have declared a list of countries and each country has an associated continent.

List<Country> countries =new List<Country>(){
new Country{Name="Japan",Continent="Asia"},
new Country{Name="Singapore",Continent="Asia"},
new Country{Name="Australia",Continent="Australia"},
new Country{Name="USA",Continent="America"},
new Country{Name="New Zealand",Continent="Australia"}
};

To filter the country which belongs to Asia we can use the either of the two queries.

1)Following query uses the query operators to filter the list of asian countries

IEnumerable<string> asianCountries = countries.Where(item => item.Continent == "Asia").Select(item => item.Name);

2)We can write the above query using query expression syntax as:

IEnumerable<string> asianCountries= from country in countries
where country.Continent == "Asia"
select country.Name;

We have both the options available when writing a Linq query.If we write a Linq query using a query expression syntax then it gets translated to query operator syntax in the IL compiled code.
Once we have declared the query we can display the result by enumerating over the collection as:

foreach (var item in asianCountries)
{
Console.WriteLine(item);
}

This was just an introduction to LINQ.There are many useful operators which we can use when writing a LINQ query.Some of the useful operators are:

• GroupBy For grouping elements
• Join For joining two data sources
• SingleOrDefault Returns a single element satisfying a condition
• Average Returns average value of a collection of values
• Count Returns the count of elements in a collection

These operators simplifies otherwise complex data access operations.

Follow on: