C# Func and Action types

The Func type provides a way to store anonymous methods. For the Func type, the first type parameters are the arguments to the methods, and the final type parameter is the return value.

Example.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using Microsoft.VisualStudio.TestTools.UnitTesting;
[TestClass]
public class UnitTest1
{
    [TestMethod]
    public void FuncTypeTest()
    {
        Func<string, bool> validator =
        word =>
        {
            var count = word.Length;
            return count > 4;
        };
        var isValid = validator("AjitGoel");
        Assert.IsTrue(isValid);
    }
}

Action type objects do not return a value. They are similar to a void method.
A Func type on the other hand returns a result.

Action<int> action1 = (int counter) => Console.WriteLine("Write {0}", counter);
Continue Reading

T-SQL Recipes Primer

Forcing sort order not directly supported by the data Eg: Retrieve only colored products and show red products first before other products.
Solution: The solution converts the value ‘Red’ into a single space, which sorts before all the color names. The CASE expression specifies LOWER(Color) to ensure ‘Red’, ‘RED’, ‘red’, and so forth are all treated the same. Other color values are forced to lowercase to prevent any case-sensitivity problems in the sort.

SELECT ProductID, Name, Color FROM Products
WHERE Color IS NOT NULL
ORDER BY CASE LOWER(Color)
WHEN 'red' THEN ' '
ELSE LOWER(Color)
END;

Present a result set to an application user N rows at a time. Eg: Skip the first ten rows and fetch the next five rows.
Solution: Make use of the query paging feature in SQL Server 2012. Use OFFSET to specify how many rows to skip from the beginning of the possible result set and FETCH to set the number of rows to return. You must specify an ORDER BY clause.

SELECT ProductID, Name FROM Product
ORDER BY Name
OFFSET 10 ROWS FETCH NEXT 5 ROWS ONLY;

Query to find Nth highest salary without using SubQuery Eg: write a query to get the 5th highest salary.
Solution: Make use of the Common table expression to get the salaries along with a row number. Then select from the common table express to get the 5th highest salary.

WITH Salaries AS(SELECT Salary, ROW_NUMBER() OVER(ORDER BY Salary DESC) AS 'RowNum' FROM Employee)
SELECT  Salary fROM  Salaries 
WHERE RowNum = 5

Differences between common table expression and temporary tables(or table variable):
A common table expression creates the table being used in memory, but is only valid for the specific query following it. Common table expression will need to be recreated every time it is needed.
A Temporary tables(or table variable) is also in-memory only, but can be used multiple times without needing to be recreated every time. Also, if you need to persist a few records now, add a few more records after the next select, add a few more records after another op, then return just those handful of records, then this is a handy in-memory structure.

Continue Reading

Generate fibonacci series

Lately I have been reading up on interview related questions. One of the other favorite interview questions interviewers have is to “write a program to generate fibonacci set of series for a user defined input number”. In mathematics, the Fibonacci numbers are the numbers in the following integer sequence(Fibonacci sequence)
0,1,1,2,3,5,8,13,21,34,55,89,144………….
So if the user inputs 8 then the output should be
0,1,1,2,3,5,8,13.

Solution

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTestProject1
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void GenerateFibonanciSeries()
        {
            var result = new StringHelper().GenerateFibonanciSeries(8);
            Assert.AreEqual(result[0], 0);
            Assert.AreEqual(result[1], 1);
            Assert.AreEqual(result[2], 1);
            Assert.AreEqual(result[3], 2);
            Assert.AreEqual(result[4], 3);
            Assert.AreEqual(result[5], 5);
            Assert.AreEqual(result[6], 8);
            Assert.AreEqual(result[7], 13);
        }
    }

    public class StringHelper
    {
         public List<long> GenerateFibonanciSeries(long numbersToGenerate)
        {
            if (numbersToGenerate <= 0)
            {
                throw new ArgumentException();
            }
            var result = new List<long>();
            long previousNumber = 0;
            long currentNumber = 1;
            result.Add(previousNumber);
            result.Add(currentNumber);
            for (int counter= 2; counter < numbersToGenerate; counter++)
            {
                long tempNumber = currentNumber + previousNumber;
                result.Add(tempNumber);
                previousNumber = currentNumber;
                currentNumber = tempNumber;                
            }
            return result;
        }
    }
}
Continue Reading

Is string same as its reversed string(i.e Is it a Palindrome)

Lately I have been reading up on interview related questions. One of the favorite interview questions interviewers have is to “write a program to check if a string is the same as its reversed string i.e check that a string is a Palindrone”. To make it more interesting, they ask to not use Array.Reverse.

Solution

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTestProject1
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void IsStringSameAsItsReversedStringThatIsItIsAPalinDrome()
        {
            var result=new StringHelper().IsStringSameAsItsReversedStringThatIsItIsAPalinDrome("Anna");
            Assert.AreEqual(result, true);
        }
    }

    public class StringHelper
    {
         public bool IsStringSameAsItsReversedStringThatIsItIsAPalinDrome(string tempString)
        {
            if(String.IsNullOrEmpty(tempString))
            {
                throw new ArgumentException();
            }
            var tempStringLower= tempString.ToLower();
            var tempArray= tempStringLower.ToCharArray();
            var tempArray1 = Reverse(tempArray);
            var reversedString=new string(tempArray1);
            if (reversedString.Equals(tempStringLower))
                return true;
            return false;
        }
        //This function just reverses a array of characters.
        private char[] Reverse(char[] characters)
        {
            for(int counter=0; counter<characters.Length/2;counter++)
            {
                char character = characters[counter];
                characters[counter] = characters[characters.Length - counter -1];
                characters[characters.Length - counter - 1] = character;
            }
            return characters;
        }
    }
}
Continue Reading

Compute value of string that has numbers seperated by arithmetic operators.

One of my friends recently went to an interview to a very well known startup company. It is supposed to hire only the very best technical people in the industry.  One of the problems that he was asked to write a unit test was,

Suppose a string has numbers separated by arithmetic operators, how do you compute the value of it?

BTW, I personally feel that you are not really testing the knowledge of a person by asking such questions and expecting them to solve it in 6 minutes.

Solution

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Data;

namespace UnitTestProject1
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            var operator1= new Operator();
            int result = operator1.Maths("2+3");
            Assert.AreEqual(result, 5);
        }

        [TestMethod]
        public void TestMethod2()
        {
            var operator1 = new Operator();
            int result = operator1.Maths("2+3*4");
            Assert.AreEqual(result, 14);
        }
        [TestMethod]
        public void TestMethod3()
        {
            var operator1 = new Operator();
            int result = operator1.Maths("2+3*10/5");
            Assert.AreEqual(result, 8);
        }
    }

    public class Operator
    {
        public int Maths(string operation)
        {
            object result=new DataTable().Compute(operation, null);
            return Int32.Parse(result.ToString());
        }
    }
}
Continue Reading

Adapter Pattern with a twist

One of my friends recently went to an interview to a very well known startup company. It is supposed to hire only the very best people in the industry.  One of the problem that he was asked to white board was:

You have a robot that can turn left and right. It can also move forward and backwards. You have a legacy robot that can only turn right and move forward. You want the legacy robot to turn left and to move backwards. Design a adapter class that would allow the legacy robot to turn right and to move backwards.

Solution

Adapter Design Pattern With A Twist

using System;
using System.Collections.Generic;
using System.Linq;
public interface IRobot
{
    void GoFront(int noOfSteps);
    void GoBack(int noOfSteps);
    void TurnRight(int degrees);
    void TurnLeft(int degrees);
}
public class LegacyRobot
{
    public void GoFront(int noOfSteps)
    {
    }
    public void TurnRight(int degrees)
    {
    }
}
public class Robot : IRobot
{
    public void GoFront(int noOfSteps)
    {
    }
    public void GoBack(int noOfSteps)
    {
    }
    public void TurnRight(int degrees)
    {
    }
    public void TurnLeft(int degrees)
    {
    }
}
public class LegacyRobotAdapter : IRobot
{
    LegacyRobot legacyRobot;
    public LegacyRobotAdapter(LegacyRobot legacyRobot)
    {
        this.legacyRobot = legacyRobot;
    }
    public void GoFront(int noOfSteps)
    {
        this.legacyRobot.GoFront(noOfSteps);
    }
    //The legacy robot can go back by turning right by 180 degrees
    //then going front by the number of steps requested by the client
    //then turning right by 180 degrees to be facing from where the robot started from. 
    public void GoBack(int noOfSteps)
    {
        this.legacyRobot.TurnRight(180);
        this.legacyRobot.GoFront(noOfSteps);
        this.legacyRobot.TurnRight(180);
    }
    public void TurnRight(int degrees)
    {
        this.legacyRobot.TurnRight(degrees);
    }
    //The legacy robot can turn left by turning right by 360 degrees minus the client requested degrees to turn
    public void TurnLeft(int degrees)
    {
        this.legacyRobot.TurnRight(360 - degrees);
    }
}
Continue Reading

Ensure a class has only one instance and provide a global point of access to it(Singleton Pattern)

Singleton Pattern:
Ensure a class has only one instance and provide a global point of access to it.

Solution:
The code below uses Double-checked locking. See here for an explanation of double checked locking.
Update(06/29/2016):
Jon Skeet’s article here, does not recommend implementing singleton pattern using Solution 1 below.
He instead recommend’s using .NET 4’s Lazy type, to implement a singleton pattern. The Lazy class internally uses double-checked locking by default to store either the exception that was thrown during construction, or the result of the function that was passed to Lazy.
I have implemented the same in Solution 2 below.

Solution 1(Not recommended):

Singleton Design Pattern

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class UnitTest1
{
        [TestMethod]
        public void SingletonTest()
        {
            var s1 = Singleton.Instance();
            var s2 = Singleton.Instance();

            if (s1 == s2)
            {
                Assert.IsTrue(true);
            }
            else
            {
                Assert.Fail();
            }
        }
}
public class Singleton
{
    private static Singleton singleton;
    private static object tempObjectForLocking = new object();
    private Singleton()
    {
    }
     public static Singleton Instance()
     {
            if (singleton != null)//First check
            {
                return singleton;
            }
            lock (tempObjectForLocking)
            {
                //Multiple processes could access the code below at the same time, 
                //therefore a "null" check has been added so only one process 
                //can create a singleton instance. 
                if (singleton == null)//Second(double) check
                {
                    singleton = new Singleton();
                }
            }
            return singleton;
     }
}

Solution 2(recommended):

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class UnitTest1
{
        [TestMethod]
        public void SingletonTest()
        {
            var s1 = Singleton.Instance();
            var s2 = Singleton.Instance();
            if (s1 == s2)
            {
                Assert.IsTrue(true);
            }
            else
            {
                Assert.Fail();
            }
        }
}
public sealed class Singleton
{
    //Using the .NET 4's Lazy<T>; type, to implement a singleton pattern. 
    //The Lazy<T>; class internally uses double-checked locking by default to 
    //store either the exception that was thrown during construction, 
    //or the result of the function that was passed to Lazy<T>.

    private static readonly Lazy<Singleton> lazy = new Lazy<Singleton>
    (
      () => new Singleton()
    );    
    public static Singleton Instance 
    { 
      get 
      { 
        return lazy.Value; 
      } 
    }
    private Singleton()
    {
    }
}
Continue Reading

Avoid accidentally throwing a NullReferenceException and null object checking code(Null Object Pattern)

Null Object Pattern:
Avoid accidentally throwing a NullReferenceException and null object checking code by using the Null Object design pattern.

using System;
using System.Linq;
    public static class StringExtensions 
    { 
        public static int GetSafeLength(this string valueOrNull) 
        { 
            return (valueOrNull ?? string.Empty).Length; 
        }
    }
    public static class Program 
    {
        static readonly string[] strings = new [] { "ajit", "goel", null, "kumar" };
        public static void Main(string[] args) 
        {
            //no need to do any checks here
            var query = from text in strings select text.GetSafeLength(); 
            Console.WriteLine(query.Sum());
        }
    }
Continue Reading

SOLID Principles in Brief

SOLID is a term describing a collection of design principles for good code. It was invented by Robert C. Martin(Uncle Bob).

SOLID means:
a. Single Responsibility Principle
b. Open/Closed Principle
c. Liskov Substitution Principle
d. Interface Segregation Principle
e. Dependency Inversion Principle

a. Single Responsibility Principle
Single Responsibility Principle states that every class should have a single responsibility. There should never be more than one reason for a class to change.

//This class violates Single Responsibility Principle since this class is doing two
//things. It is dealing with both opening \ closing connections and with 
//data communication.
public interface IDatabase
{
    void Connect(string connectionString);
    void Close();
    object GetData();
    void SendData(object data);
}

Refactored code to follow Single Responsibility Principle and Open\closed principle:

//IDatabase class has now been refactored into two classes. The IDataManager 
//class deals with data communication.The IConnectionManager 
//class deals with opening \ closing connections. These classes now follow the 
//Single Responsibility Principle.
public interface IDataManager
{
    object GetData(IConnectionManager connManager);
    void SendData(IConnectionManager connManager, object data);
}
public interface IConnectionManager
{
    void Connect(string connectionString);
    void Close();
}

b. Open/Closed Principle
Open/Closed Principle states that software entities should be open for extension, but closed for modification.

In the example above, refactoring IDatabase into IConnectionManager, IDataManager classes allows the client application to either
a. if the client application likes to change the way it opens or closes connection, it can implement its own IConnectionManager and pass it to the IDataManager class i.e Without touching the original code, it is able to extend the functionality of the classes without actually breaking the already existing class.
b. if the client application likes to change the way its getting or sending data it can implement its own IDataManager and use it with the already existing implementation of IConnectionManager.

c. Liskov Substitution Principle
Liskov Substitution Principle states that code that uses a base class must be able to substitute a subclass without knowing it.

public class DatabaseRepository
{
    //This method violates Liskov Substitution Principle since it consumes an object 
    //of a base type but internally uses the base type's subclass. According to 
    //Liskov Substitution Principle, it should not know it is using base class 
    //or its subtypes. 
    public bool TestConnection(IConnectionManager connMngr)
    {
        if (connMngr is SqlServerConnectionManager)
        {
            // Do something...
        }
        else if (connMngr is OracleConnectionManager)
        {
            // Do something else...
        }
        else
        {
            // ...
        }
    }
}
public interface IConnectionManager
{
    void Connect(string connectionString);
    void Close();
}
public class SqlServerConnectionManager: IConnectionManager
{
    public void Connect(string connectionString)
    {
    }
    public void Close()
    {
    }
}
public class OracleConnectionManager : IConnectionManager
{
    public void Connect(string connectionString)
    {
    }
    public void Close()
    {
    }
}

d. Interface Segregation Principle
The Interface Segregation Principle states that clients should not be forced to implement interfaces they don’t use.

Existing Design
Let’s assume we have to implement a new Robot class in this design. Robots will need to implement the IWorker interface because robots works. On the other side, they don’t have to implement it because they don’t eat. If we keep the present design, the new Robot class is forced to implement the “eat” method.

public interface IWorker 
{
	public void Work();
	public void Eat();
}
public class Worker : IWorker
{
	public void Work() 
        {
	}
	public void Eat() 
        {
	}
}
public class Manager 
{
	IWorker worker;
	public void SetWorker(IWorker w) 
        {
		worker=w;
	}
	public void Manage() 
        {
		worker.Work();
	}
}

Interface Segregation Principle implemented in current design

//Following code supports the Interface Segregation Principle. By splitting the 
//IWorker interface in IFeedable, IWorkable interfaces the new Robot class is 
//no longer forced to implement the "eat" method.
public interface IWorker : IFeedable, IWorkable 
{
}
public interface IWorkable 
{
	public void Work();
}
public interface IFeedable
{
	public void Eat();
}
public class Worker : IWorkable, IFeedable
{
	public void Work() 
        {
	}
	public void Eat() 
        {
	}
}
public class Robot : IWorkable
{
	public void Work() 
        {
	}
}
public class Manager 
{
	IWorkable worker;
	public void SetWorker(IWorkable w) 
	{
		worker=w;
	}
	public void Manage() 
	{
		worker.Work();
	}
}

e. Dependency Inversion Principle
Dependency Inversion Principle states that
1. High-level modules(Manager class) should not depend on low-level modules(Worker, SuperWorker classes). Both(Manager, Worker, SuperWorker classes) should depend on abstractions(IWorker).
2. Abstractions should not depend on details. Details should depend on abstractions.

Existing Design
Let’s assume we have to implement a new SuperWorker class in this design. If we do that then we will have to change the Manager.Manage() method also which introduces risk.

public class Worker 
{
	public void Work() 
	{
	}
}
public class SuperWorker: Worker 
{
	public void Work() 
	{
	}
}
public class Manager 
{
	Worker worker;
	public void SetWorker(Worker w) 
	{
		worker = w;
	}
	public void Manage() 
	{
		worker.Work();
	}
}

Dependency Inversion Principle implemented in current design

//Following code supports the Dependency Inversion Principle. In this new design 
//a new IWorker Interface has been added. Now the Manager class doesn't require 
//changes when SuperWorkers are added since the work has been delegated to the 
//SuperWorker class.It also reduces risk since no other parts of the system need 
//to be tested.
public interface IWorker 
{
	public void Work();
}
public class Worker : IWorker
{
	public void Work() 
	{
	}
}
public class SuperWorker : IWorker
{
	public void Work() 
	{
	}
}
public class Manager 
{
	IWorker worker;
	public void SetWorker(IWorker w) 
	{
		worker = w;
	}
	public void Manage() 
	{
		worker.Work();
	}
}

Dependency Injection is about how one object acquires a dependency.
Inversion of Control (IoC) means that objects do not create other objects on which they rely to do their work. Instead, they get the objects that they need from an outside source (for example, an xml configuration file).
Dependency Injection (DI) means that this is done without the object intervention, usually by a framework component that passes constructor parameters and set properties.

Dependency Injection Container is a way to auto-wire classes

Continue Reading

Database performance tuning concepts in brief

Predicates are used to used to specify a subset of rows to be returned. They are specified in the WHERE clause of a SQL statement.
In the example below “Id = 1” is a predicate:

SELECT * FROM Employee WHERE Id = 1;

Estimated Execution Plan defines how a query should actually execute
Actual Execution Plan tells what happened while a query was executed.
Table Scan/Index Scan looks at each and every row available in the table/index
Index Seek has address of each row based on the key field value. So seek directly goes to that data page and fetches the row if your predicate matches with the key field.
Key Lookup, In case of Key lookup, SQL server storage engine has to go from non-clustered index to clustered index, in order to fetch the value of non-key field of non-clustered index. This round-trip always consumes time and decreases performance.

Continue Reading