C#

Merge multiple Lists using LINQ Zip operator in C#

June 1, 2018 by ashish Leave a Comment

Zip operator in C# is used for merging or combining two sequences into one sequence.If you have two lists of elements and you want to create a third list by combining elements in the two lists then you can use Zip LINQ operator.It is included as a query operator in C# 4.0 onward.

Suppose if you have two classes defined for Employees working in your organisation and the departments to which they are assigned:

class Employee
{

public string Name { get; set; }
public int Id { get; set; }
public decimal Salary { get; set; }
public int Grade { get; set; }
}

class EmployeeDepartment
{

public int Id { get; set; }
public string Department { get; set; }
}

In this case you will have two separate collections defined for employees and their departments:

list of employees:

List<Employee> emps = new List<Employee>();
emps.Add(new Employee { Name = "Employee1", Salary = 1000, Grade = 1 });
emps.Add(new Employee { Name = "Employee2", Salary = 1000, Grade = 2 });

list of departments:

List<EmployeeDepartment> empdepts = new List<EmployeeDepartment>();
empdepts.Add(new EmployeeDepartment {Id=1,Department="HR" });
empdepts.Add(new EmployeeDepartment { Id = 2, Department = "Finance" });

Now problem is employees are assigned to their departments based on employee Id.So if you want to see the names of the employees in the different departments then you can use:

So after sorting the list of EmployeeDepartment and Employees by their Ids you can merge the two collections:

var empDepartmens= emps.Zip(empdepts, (e, s) => e.Name+" "+s.Department );

ashish

Follow on:

Find difference between Lists in C# using LINQ

May 30, 2018 by ashish Leave a Comment

Here we will see how we can find the difference between two lists in C# using LINQ.

Suppose you have two lists of elements lstA and lstB declared as:

List<string> lstA = new List<string> { "A", "B", "C", "D","G" };
List<string> lstB = new List<string> { "A", "B", "C", "D","F" };

Using Except extension method

Here we are interested in finding the difference between the two lists.Here we can use the Except extension method.This method returns the items which are there in the first collection but not there in the second collection.

So if are interested in only finding the items which are there in the first list but not in the second list then you can use the Except method as:

var difference=lstA.Except(lstB).ToList();

Above will return the alphabet “G”

But if you are only interested in finding the difference between the lists then you can use the following

List<string> difference = new List<string>();
if(lstA.Count()>lstB.Count())
difference=lstA.Except(lstB).ToList();
else
difference=lstB.Except(lstA).ToList();

Using Where extension method

You can also use the where method to find elements which are in the first list but not in second list:

var difference= lstA.Where(p =>!lstB.Contains(p));

ashish

Follow on:

Compare two generic lists in c# using linq

May 30, 2018 by ashish Leave a Comment

To Compare two generic lists in c# using linq ,we need to compare some of the properties of the generic lists.

So if we have two generic lists declared as:

List<string> lstA = new List<string>{ "A", "B", "C" };
List<string> lstB = new List<string> { "A", "B", "C" };

then we can compare the lists for equality by using the following logic:

1.Compare the types of generic lists

2.Compare the number of elements in the list

3.Compare if both the lists consists of common items

We can implement the above logic as:

//get the type of elements in the list
var a = lstA.GetType();
var b = lstB.GetType();
//check if the types are same
if (a == b)
{
//check if the count is same
   if (lstA.Count() == lstB.Count())
     {
          //check if both the lists contains the common items
          var filteredSequence = lstA.Where(x => lstB.Contains(x));
          if(filteredSequence.Count()==lstA.Count())
            {
             //lists are same
             }
         else
           {
           //lists are not same
            }
}
}

We can move the above logic in a method as:

private static bool CompareGenericLists(List<string> lstA, List<string> lstB)
{
var a = lstA.GetType();
var b = lstB.GetType();

if (a == b)
{
if (lstA.Count() == lstB.Count())
{
var filteredSequence = lstA.Where(x => lstB.Contains(x));
if (filteredSequence.Count() == lstA.Count())
{
return true;
}
else
{
return false;
}
}
}
else
{
return false;
}
return false;
}

ashish

Follow on:

Convert Enum to String in C#

May 25, 2018 by ashish Leave a Comment

Enum type provides the GetName() and GetNames() methods which we can use to Convert Enum to String in C#.

Enum.GetName() method

GetName() method returns an equivalent string value for a given enum value.

We have declared the following enum EmployeeDepartment:

public enum EmployeeDepartment
{
IT,
HR,
Admin
}

If you have a variable of type EmployeeDepartment then you can convert it to equivalent string value by using the GetName() method as:

static void Main(string[] args)
{
EmployeeDepartment empDept = EmployeeDepartment.IT;
string name = Enum.GetName(typeof(EmployeeDepartment),empDept);

}

Above program will print the following:

Enum.GetNames() method

GetName() method returns equivalent string values(string array) for a given enum.If we want to retrieve string values for the enum EmployeeDepartment declared above then we can use the following logic:

string[] empTypes = Enum.GetNames(typeof(EmployeeDepartment));

ashish

Follow on:

Exception Filter in C#

May 22, 2018 by ashish Leave a Comment

C# 6 introduces a new way of handling errors.C# 6 has new keyword when which is used with a catch block.

try catch block is used for error handling in C#.If a error occurs in a try block then control is transferred to the catch block.C# 6 introduces exception filters.Exception filter is applied to a catch block.Exception filter is a predicate which can return true/false values.

If an exception filter is applied to a catch block the following happens if an error occurs
If the exception filter evaluates to true value then the corresponding catch block is executed
If the exception filter evaluates to false value then the corresponding catch block is not executed

The exception filters are quite useful when there are nested method calls.Normally one method calls second method which calls third method and so on.
So assume NestedMethod1 calls NestedMethod2 which calls NestedMethod3. Following is the code for the scenario:

class Program
{
static void Main(string[] args)
{
try
{
MainMethod();
Console.WriteLine("Hello from Main");
}
catch(Exception exp) when(true)
{
Console.WriteLine("Hello from exception");
}
}

public static void MainMethod()
{
NestedMethod1();
Console.WriteLine("Hello from MainMethod");
}

public static void NestedMethod1()
{
NestedMethod2();
Console.WriteLine("Hello from NestedMethod1");
}

public static void NestedMethod2()
{
NestedMethod3();
Console.WriteLine("Hello from NestedMethod2");
}

public static void NestedMethod3()
{
throw new Exception();
Console.WriteLine("Hello from NestedMethod3");
}
}

Now if an exception occurs inside NestedMethod3 then in a normal scenario the call stack will contain the list of all the methods in the call hierarchy as:

If an error occurs and you are catching the error in main method then the entire call stack is lost:

If you are using when keyword in C# 6 or later then if the when predicate is true only then the catch block is executed.One benefit of this is that you can log the error before handling the exception in catch block:

try
{
MainMethod();
Console.WriteLine("Hello from Main");
}
catch(Exception exp) when(LogError())
{
Console.WriteLine("Hello from exception");
}

ashish

Follow on: