LINQ Standard Query Operators

If you are an experienceg .NET developer then you might be aware of LINQ and it's advantages. Yes it's a uniform query language to get and filter data from various data sources.

Fine, but LINQ is beyond that and we can combine various functions and operators associated with a LINQ query. Believe it or not, by using those functions we can make LINQ more robust for data processing and manipulation queries.

This article shows various functions and operators associated with LINQ and we will see how it makes data processing operations simple.

We can categorize the operators in many categories. Let's see a few of them.

Aggregation

Here we will understand various LINQ operators that will work on data, let's start with aggregation. Here is a few examples.

namespace ConsoleApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //Example of aggregration

            int[] data = { 1, 2, 3, 4, 5 };
            //Sum of numbers
            Console.WriteLine(data.Sum());   //ans:15
            //Average of numbers
            Console.WriteLine(data.Average()); //Ans :3
            //Max of numbers
            Console.WriteLine(data.Max());  //Ans :5

            String[] strdata = {"1","two","three","four","five"};

            //Item with minimum length
            Console.WriteLine(strdata.Min());  //Ans :1

            //Item with minimum character(same as above)
            Console.WriteLine(strdata.Min(f=>f.Length));  //Ans:1

            //Items with maximum character
            Console.WriteLine(strdata.Max(f => f.Length)); //Ans :5

            Console.ReadLine();
        }
    }
}

Concatination

A Concatenation operation takes place when we want to combine more than one element. In this example we have used the Concat function to combine two arrays. I believe many developers don't know the shortcut to combine two arrays, sometimes they use foreach or some kind of iterative statement to do the same job.

using System;
using System.Collections.Generic;
using System.Linq;
    public class Program
    {
        public static void Main(string[] args)
        {
            //First array
            int[] data = { 1, 2, 3 };

            //Concatination with another array
            int[] result = data.Concat(new int[] { 4, 5, 6 }).ToArray();
            //result 1,2,3,4,5,6
        }
    }

Conversion

The dictionary meaning of conversion is applicable here. To convert one type to another type, we can use a Cast parameterized function. In this example I am showing how to convert from IEnumerable to a list and an array.

public static void Main(string[] args)
{
      object[] data = { "1", "2", "3", "4", "5" };
      //Cast to Ienumerable<string>
      IEnumerable<string> strEnum = data.Cast<string>();
      //Cast to List
      List<string> strList = data.Cast<string>().ToList();
      //Cast to Array
      string[] strArray = data.Cast<string>().ToArray();
}

Element operation

It's very common in applications that we sometimes need a direct element, direct in the sense that we want to pick the element by it's index or by a query. There are many functions available with which we can combine a lambda expression to simplify our job.

public static void Main(string[] args)
{
    int[] data = { 1, 2, 3, 4, 5 };
    data.ElementAt(10);   //Error
    data.ElementAtOrDefault(10);  //null
    data.First();  //1
    string[] name = {"sourav","Ram","Shyam"};
    //First three letter name
    name.First(m => m.Length == 3); // Ram
    //First name which is greater then 3
    name.First(m => m.Length > 3); //sourav
    //Last element of array
    name.Last();  //Shyam
    //Get one element
    name.Single(); //Exception. More than one element
    //Try to get single element if empty array then return null
    name.SingleOrDefault();  //Exception: More than one element
    //try to get item whose length is 10
    name.SingleOrDefault(m => m.Length == 10);  //null
 }

Equality

Equality checking between lists or some kind of collection is another common requirement in applications. If we want to check whether or not the words are sequentially arranged then we can use the SequenceEqual function. Although there are many I will mention the uncommon one.

public static void Main(string[] args)
{
    //Equality checking.
    string[] words = { "sourav", "Ram", "Shyam" };

    //Check whether all items are present sequencially or not
    words.SequenceEqual(new[] { "sourav", "Ram", "Shyam" });  //Ans : True

    //Case is different
    words.SequenceEqual(new[] { "SOURAV", "RAM", "SHYAM" }); //False

    //Ignore cases in checking
    words.SequenceEqual(new[] { "SOURAV", "RAM", "SHYAM"}, StringComparer.OrdinalIgnoreCase); //True
}

Partitioning

This operation divides the entire set into two partitions and picks one of them. In this example we will see few functions combine with a lambda expression.

public static void Main(string[] args)
{
    string[] name = { "one","two", "three" };
    // take two elements from list
    name.Take(2).ToList<string>();  // one two

   //Skip first one element in list
   name.Skip(1).ToList<string>(); //two three

   //Take eleents whose length is 3
   name.TakeWhile(f => f.Length == 3);  //one two

   //Skil element when length is less than 4
   name.SkipWhile(f => f.Length < 4); // three

   Console.ReadLine();
}

Projection

This operation is needed when we want to take a certain part from a collection. Here, we are taking part of a name array by length, by its index position. Have a look at the following example.

public static void Main(string[] args)
{
      string[] name = { "one","two", "three" };
      //Find lenght if all element.
      name.Select(f => f.Length);  // 3 3 4
     //print element with index
     name.Select((a, b) => b.ToString() + ":" + a);  // 0 : one 1: two 2:three
     //Print items nuber of times by it's index
     //For example one is in 0th position - so not printed
     //two is in 1st position - so printed one time
     //Three is in 2nd position - so printed 2 times
     name.SelectMany((a, b) => Enumerable.Repeat(a, b)).ToArray(); //two three three
     Console.ReadLine();
}

Set based operation

A set based operation is not a very common in day-to-day programming, but it's useful to understand an overview of the functions. It's very similar to a normal math set operation. Just have a quick look at the following example.

public static void Main(string[] args)
{
     //set based operation
     string[] first = { "a", "b", "b" ,"c" };
     string[] second = { "c", "d", "e" };

     //Select unique element
     first.Distinct();  // a,b,c

     //Intersect -Take common
     first.Intersect(second);  // c

     //Union - Get all unique element
     first.Union(second);      //a b c d e

    //Except
    first.Except(second);     // a b
    Console.ReadLine();
}

Filtering

Filtering is very essential in day-to-day programming. In this example we will see a few useful filtering functions associated with lambda expressions.

public static void Main(string[] args)
{
    //Sorting
    string[] name = {"one","two","three" };

    //Order collection alphabetically- First character
    name.OrderBy(f => f).ToArray();  //one three two

    //arrange alphabetically on second character
    name.OrderBy(f => f[1]); // three one two

    //Order by length
    name.OrderBy(f => f.Length);  //one two three

    //Order by length descending
    name.OrderByDescending(f => f.Length);

   //First by length then Descending.
   name.OrderBy(f => f.Length).ThenByDescending(f => f); //two one three

   Console.ReadLine();
}

Conclusion

This article showed various functions associated with LINQ and lambda expressions. It's good to understand those functions to reduce the amount of code and program complexity.