Friday, 18 May 2012

LINQ Zip Operator

The Zip operator was added in Framework 4.0. It enumerates two sequences in step (like a zipper), returning a sequence based on applying a function over each element pair.
The extension method signature is:
   1: public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
   2:                                     this IEnumerable<TFirst> first,
   3:                                     IEnumerable<TSecond> second,
   4:                                     Func<TFirst, TSecond, TResult> resultSelector)
Zip cycles through two sequences using deferred execution. The items at the same index are paired and each pair is transformed using a function that is usually provided as a lambda expression. The sequence stops as soon as one of the sequences exhausts its elements; ideally, the sequences are identical in length or you can say in other word continues until all of the items in either sequence have been processed. If one sequence has more elements than the other, the extra elements are not projected into the new sequence. The merging happens in the func function. It takes two arguments (the element from first source, and the element from the second source) and lets you return a combined type.

Example:
   1: using System;
   2: using System.Linq;
   3:  
   4: namespace ZIP_OPERATOR_DEMP
   5: {
   6:   class Program
   7:   {
   8:     static void Main(string[] args)
   9:     {
  10:       //Initialize two lists of integer with same sequence.
  11:       int[] integers1 = new int[] { 1, 2, 3, 4, 5 };
  12:       int[] integers2 = new int[] { 10, 20, 30, 40, 50 };
  13:  
  14:       //Now apply zip operator on it.
  15:       var sumsZip = integers1.Zip(integers2, (i, j) => i + j);
  16:  
  17:       Console.WriteLine("Output of zip of two interger series.");
  18:       Console.WriteLine("=====================================");
  19:  
  20:       //Get the out of Zip operation.
  21:       foreach (var sum in sumsZip)
  22:       { Console.WriteLine(sum); }
  23:  
  24:       Console.WriteLine("\n");
  25:  
  26:       //Initialize two lists with different sequence and different datatypes.
  27:       int[] integers3 = new int[] { 1, 2, 3, 4, 5 };
  28:       char[] characters = new char[] { 'A', 'B', 'C', 'D', 'E', 'F' };
  29:       var items = characters.Zip(integers3, (c, i) => string.Format("{0}{1}", c, i));
  30:  
  31:       Console.WriteLine("Output of zip of two different datatype series.");
  32:       Console.WriteLine("===============================================");
  33:  
  34:       //Get the out of Zip operation.
  35:       foreach (var item in items)
  36:       { Console.WriteLine(item); }
  37:  
  38:       Console.WriteLine("\n");
  39:  
  40:       //Now we zip more then two list with one by one basis.
  41:       //So final output will be full address line for each element.
  42:       var bldgNum = new string[] {"A5", "A2", "A1" };
  43:       var flatNum = new int[] {104, 109, 25, 200 };
  44:       var streetNm = new string[] {"Baker Street", "Cross Street", "Hu Street" };
  45:       var city = new string[] { "CO", "WA", "AU", "CA" };
  46:  
  47:       Console.WriteLine("Output of multiple zip operation multiple series.");
  48:       Console.WriteLine("=================================================");
  49:  
  50:       //Zip all the partiall address to full address.
  51:       var address = bldgNum.Zip(flatNum, (bl, fl) => bl + ", " + fl.ToString())
  52:                            .Zip(streetNm, (fl, st) => fl + " , " + st)
  53:                            .Zip(city, (st, ct) => st + ", " + ct);
  54:  
  55:       foreach (var addr in address)
  56:         Console.WriteLine(addr);
  57:  
  58:       Console.ReadLine();
  59:     }
  60:   }
  61: }
Output:
clip_image002 
Explanation:

For the first example we'll zip together two sequences containing the same number of elements, where each sequence contains the same data type. In the code below you can see that the Zip operator is used as an extension method of the first array. The second array is passed to the first parameter. The second argument specifies the projection function that is used to generate the items in the resultant collection. In this case each pair of values is summed.
In the second example we add an array of characters so that we can demonstrate combining sequences of differing types. Here a character and an integer from the source arrays are combined with string.Format to generate a string. Note also that the list of characters is longer than the integer sequence. The final item, "F", is dropped from the results. 

Conclusion:

We can use this "ZIP" linq operator where we want some action to perform on same or different data types sequences but operator consider only "Source" & "Destination" index match else ignore other element in sequence.
For more details you can refer MSDN.

No comments:

Post a comment