ashish

Introduction to LINQ

November 8, 2015 by ashish Leave a Comment

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.

ashish

Follow on:

Convert string to Title and Sentence Case in C#

November 3, 2015 by ashish Leave a Comment

While working with strings two of the most common requirements are to convert string to title and Sentence case .We can use inbuilt and custom methods in c# for these tasks.

We will see how to convert string to Title and Sentence Case in C#.

Following are two of the methods for converting string:

Convert String to Title Case

Sometimes we have the requirement while working with textual data to convert the text into title case.If we just want to convert every word in the text to title case then we can use the ToTitleCase method.The ToTitleCase(string) is a method defined in the TextInfo class of the System.Globalization namespace.

To convert the string to title case we just pass the string to the ToTitleCase(string) method.Below we are passing some string value to this method

static void Main(string[] args)
{
string text = "This is a sample text";
string titleCaseText = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text);
Console.WriteLine(sentence titleCaseText);
Console.ReadLine();
}

On executing the above code we get the following output

Convert String to Sentence Case

Though we can use the ToTitleCase(string) method for converting a string to a title case but when working with a paragraph we need to convert the first word of a sentence to title case.For this we can use the following code.

class Program
{
//Create a new delegate type
public delegate string FormatString(string rawString);
static void Main(string[] args)
{
string strParagraph = "first sentence.second sentence";
FormatString format = RemoveSpace;
string formatted = RemoveSpace(strParagraph);
FormatString split =Split;
var finalString = Split(formatted);

Console.WriteLine(finalString);
Console.ReadLine();
}

public static string RemoveSpace(string fullString)
{
return fullString.Trim();

}

public static string Split(string fullString)
{
var strArr = fullString.Split(new char[] { '.' });
var newStrArr=strArr;
foreach (var item in strArr)
for(int iCount=0;iCount<strArr.Count();iCount++)
{
strArr[iCount]=strArr[iCount].Insert(0, strArr[iCount][0].ToString().ToUpper());
strArr[iCount] = strArr[iCount].Remove(1, 1);
}
return string.Join(".", strArr);
}
}

In the above example a delegate type FormatString is declared as:

 public delegate string FormatString(string rawString);

The method RemoveSpace is assigned to delegate FormatString and is called.

FormatString format = RemoveSpace;
string formatted = RemoveSpace(strParagraph);

the result of the first method call is passed to the second second delegate instance.The second instance refers to the Split method.

FormatString split = Split;
var finalString = Split(formatted);

In the Split(string) method the passed argument is split based on the “.” separator.

var strArr = fullString.Split(new char[] { '.' });

Finally we loop over the array and convert the first word to title case.

 strArr[iCount] = strArr[iCount].Insert(0, strArr[iCount][0].ToString().ToUpper());

we get the following output on executing the above example

ashish

Follow on:

StackTrace class in C#

November 1, 2015 by ashish Leave a Comment

In every application there are a sequence of method calls.A method may call second method which may call the third method.
This sequence of method calls is known as the call stack.In .NET this call stack is represented by the StackTrace class.

We can access the StackTrace information for understanding the execution of the program and for other debugging purposes.
In the following program method Method1 calls Method2 which calls Method3.

class StackTraceDemo
{
public void Method1()
{
Console.WriteLine("Method1");
Method2();
}

public void Method2()
{
Console.WriteLine("Method2");
Method3();
}

public void Method3()
{
Console.WriteLine("Method3");
}

}

We are calling the method Method1 from the Main() method as

static void Main(string[] args)
{
StackTraceDemo obj = new StackTraceDemo();
obj.Method1();

Console.ReadLine();
}

On executing the above program we get the following output

We were able to identify the sequnce of method calls from the Console.WriteLine() methods.But using the Console.WriteLine() statements might not be always possible.So we use the StackTrace class for debuging the application.StackTrace class in C# represents a stack of method calls.To access a specific method call we can use the StackFrame class.

So if we comment the Console.WriteLine() methods in the above example and use the stack trace class we will be able to get detailed information about the method calls

class StackTraceDemo
{
public void Method1()
{
//Console.WriteLine("Method1");
Method2();
}

public void Method2()
{
// Console.WriteLine("Method2");
Method3();
}

public void Method3()
{
//Console.WriteLine("Method3");

StackTrace stackTrace = new StackTrace(); // get call stack
StackFrame[] stackFrames = stackTrace.GetFrames(); // get method calls (frames)

// write call stack method names
foreach (StackFrame stackFrame in stackFrames)
{
Console.WriteLine(stackFrame.GetMethod().Name); // write method name
}
}

}

class Program
{
static void Main(string[] args)
{
StackTraceDemo obj = new StackTraceDemo();
obj.Method1();

Console.ReadLine();
}
}

We get a similar output when we use the StackTrace to print the sequence of method calls.

ashish

Follow on:

The dynamic type in C# 4.0

November 1, 2015 by ashish Leave a Comment

The dynamic type was introduced in C# 4.0. It’s a new type like other data types such as int or double.The difference between dynamic type and other types is that dynamic type variable is not type checked by the compiler.So any value can be assigned to a dynamic type variable.

If we declare a variable of type dynamic as

dynamic strObj = "hello";
dynamic intObj = 1;

as you can see above values of type string and int are assigned to a dynamic variable.
But the main advantage of dynamic type is that the compiler will not check if the operations performed by a dynamic type variable are valid or not.So if we write the following statement our program will compile successfully.

strObj.NewMethod();

Even though the method NewMethod() is not defined by the string type still our code just compiles.Though at run time error will be thrown as NewMethod() doesn’t exist in the string type.

Use of dynamic type

If we are calling an API which is implemented in different language then by using the dynamic type we can easily call the API from our .NET code.
For example the data types used in java or python differs from the data types used in .NET.So if we are not using dynamic type then we need to cast the arguments to and from the object type to the actual .NET data type.By using the dynamic type in C# 4.0 we can avoid type type casting by using the dynamic type as API method arguments.

Some of the important points about dynamic type are:

dynamic types should be used only when necessary.As dynamic type variable are not type checked by the compiler so it increases the chances of runtime exceptions in our application.
It provides advantage over using objects for storing different types as type casting is not required.
The dynamic language runtime or DLR is an API introduced in .NET Framework 4 which provides the ability to use dynamic type.
The dynamic type in C# 4.0 can be assigned different types of values.For example the variable strObj is assigned the value “hello” and the reassigned the integer value 1.

dynamic strObj = "hello";
strObj = 1;

ashish

Follow on:

Use and Example of Singleton Pattern in C#

October 26, 2015 by ashish Leave a Comment

Name Singleton
Type Creational Pattern

Many times we need to restrict a class to only a single instance.Singleton pattern restricts the clients of the class from creating multiple instances of the class.There is a global access point ,such as a method,which returns the same object every time it is invoked.Singleton pattern is a creational pattern since it specifies how to create an object of a class.Here we will see the use and example of Singleton pattern in C#.

We can represent Singleton pattern with the following diagram

To implement singleton pattern follow the below steps

Declare a private constructor: This ensures that consumers of the class can not create objects of the class.If we allow consumers to create new objects then we will not be able to restrict the class to a single instance.
Declare a static field in the class.
Declare a static method: This will return the static field declared in step 2.This method will create a new instance of the field if its doesn’t already exists.

The purpose of step 3 above is to ensure that there is a single interface for accessing the instance of singleton class.Singleton pattern doesn’t specify whether it should be a method or property.So we can implement this as a method or property.

Example of Singleton Pattern

In the following example we have declared a class Singleton which implements the Singleton pattern.This class defines a private constructor,a static field and a method CreateObject.CreateObject method created a new object of the class if it doesn’t exists.

There is an Id property which uniquely identifies each object.As this class can have only single instance so this property will never be incremented and should be always 1.

public class Singleton
{
private static Singleton _object;
public int Id { get; set; }
private Singleton()
{
Id = Id + 1;
}
public static Singleton CreateObject()
{
if (_object == null)
{
_object = new Singleton();
}

return _object;
}

}

User create new object of the Singleton class by calling the CreateObject() method.We are calling the CreateObject method two times.We assign the references returned by the method calls to two different variables.

When we compare the two object references as:

singletonObject1==singletonObject2

they should be equal.

class Program
{
static void Main(string[] args)
{
//Following is not allowed and will give compilation error
//int id = 1;
//Singleton obj = new Singleton(id);

Singleton singletonObject1 = Singleton.CreateObject();
Console.WriteLine("Object created.Object id is {0}", singletonObject1.Id);

//try to create second object
Singleton singletonObject2 = Singleton.CreateObject();
Console.WriteLine("Object created.Object id is {0}", singletonObject2.Id);

if(singletonObject1==singletonObject2)
{
Console.WriteLine("Can not create second object.Singleton class can have only a single instance");
}
else
{
Console.WriteLine("Successfully created second object");
}
Console.ReadLine();
}
}

As we can see from the output both the object references refers to the same object

We have used static method above to create instance of the singleton class.We could use static property instead of static method in our Singleton class:

public class Singleton
{
private static readonly Singleton _object= new Singleton();
public int Id { get; set; }
private Singleton()
{
Id = Id + 1;
}
 public static Singleton Instance
 {
 get
 {
 return _object;
 }
 }

}

Use of Singleton pattern

Some of the scenarios where Singleton pattern could be useful are:

A common use of Singleton pattern is implementing the logging class.Since logging class needs to be used multiple times in a application hence it is useful to implement it as a singleton.
Often data fetched from a database needs to be cached.This cache class can be implemented as a singleton class since we need to have a single instance of the cached items.
If we have an object that is resource intensive and so expensive to create ,it’s useful to implement it as a singleton.

Problem to avoid when implementing Singleton pattern

A problem can occur when there are singleton class is simultaneously accessed in a multi-threaded environment .In such cases the first call to singleton class creates an object,but it is not visible to the second call.So the second access to singleton class will try to again create an object of the singleton class.

A simple solution to concurrency is using the C# lock statement

lock (_object)
{
if (_object == null)
{
_object = new Singleton();
}
return _object;
}

A common example of Singleton Pattern in C# is implementing logger as a singleton class.Since logging is a cross cutting concern so it can implemented as a singleton class.

When developing a application design patterns should be chosen cautiously after weighing the pros and cons.Singleton design pattern is useful when the primary requirement is to limit the number of instances to a single instance.There could be different ways to implement the same design pattern.In the above example we have implemented singleton pattern in c# using a method but we could have used a property instead.

ashish

Follow on: