New Features in C# 2008

Object Initializers

Fields or properties of an object can be initialized and values can be assigned at the creation time with out calling the constructor to initialize these members.

Let's learn this from the below example.

internal class Employee

{

private int iEmpID;

private string strEmpName;

public int EmpID

{

get { return iEmpID; }

set { iEmpID = value; }

}

public string EmpName

{

get { return strEmpName; }

set { strEmpName = value; }

}

public Department Dept {get;set;}

}

We have defined an Employee class with few attributes. Let's now create an object for this class and initialize the Employee object.

var Emp = new Employee{EmpID = int.Parse("1234"), EmpName = "Chandra"};

Above code snippet creates a new Employee object by assigning values to the properties.

This code results in same output as follows

Employee Emp = new Employee();

Emp.EmpID = int.Parse("1234");

Emp.EmpName = "Chandra";

Collection Initializers

Just like Object Initializers collections can be initialized easily using Collection Initializers. In the below example, a new Integer array is constructed and initialized with some element values.

var c = new Int32[] { 1, 2, 3 };

Same construct can be used to initialize custom object (List<T>) collections also.

internal class Address

{

public string StreetName { get; set; }

public string City { get; set; }

public string Country { get; set; }

}

A new Address class is defined to hold Street name, City and Country. We are going to initialize objects of Address class using collection initializers. Here object initializers are separated by commas with in the braces of collection initializers.

var lstAddress = new List<Address>

{

new Address{StreetName = "Mount Road", City = "Chennai", Country="India"},

new Address{StreetName = "M.G.Road", City = "Bangalore", Country="India"}

};

Anonymous Types

Without explicitly defining a type, we can define types that have encapsulated read-only properties. These types are anonymous and compiler generates the type name as required. These types were not defined by the programmers at the design time and are not available at the source code level. These anonymous types are nothing other than unnamed structure types. These types can be accessed by using var keyword.

var objEmployee = new

{

EmpID = 3235,

EmpName = "Chandra"

};

IDE provides intellisense at the design time itself.

Lambda Expressions

It's nothing but Anonymous Methods that contain expressions and statements. It is a replacement to C# 2.0 Delegates. Lambda expressions are more of a functional syntax.

Let's look at an example how delegates are defined in the earlier releases of C#. This way you should be able to understand and appreciate the functional syntax.

C# 1.0 Syntax:

delegate int Sum(int i, int j);

public void Learn()

{

Sum objSum = new Sum(Add);

Console.WriteLine(objSum(5, 5));

}

private static int Add(int i, int j)

{

return i + j;

}

C# 2.0 using Anonymous methods:

delegate int Sum(int i, int j);

public void Learn()

{

Sum objSum = delegate(int i, int j) {return i + j;};

Console.WriteLine(objSum(5, 5));

}

C# 3.0 using Lambda Expressions:

delegate int Sum(int i, int j);

public void Learn()

{

Sum objSum = (int i, int j) => i + j;

Console.WriteLine(objSum(5, 5));

}

Let's learn how to create Lambda expressions. Lambda operator => is used to define these expressions. It is read as "goes to".

E.x.

i => i * 2

Input parameters to the expressions are defined before the Lambda operator =>. Expressions are defined on the right-hand side part of the Lambda operator.

We can also define Lambda statements by defining more than one statement encapsulated inside { }. return statement should be part of the statement Lambdas.

delegate int Sum(int i, int j);

public void Learn()

{

Sum objSum = (int i, int j) => { return i + j; };

Console.WriteLine(objSum(5, 5));

}

Standard Delegates

C# 3.0 comes with few standard delegates. This helps programmers to create a delegate up to 4 parameters without creating their own. Below is the method reference.

public delegate TResult Func<TResult>(); // with no parameters

public delegate TResult Func<T, TResult>(T arg); // with One parameters

public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2); // with 2 Parameters

public delegate TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3);

public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

A simple example is given below:

// using Func delegates adding 2 string and returning string...

Func<string, string, string> cdL3 = (one, two) => { return one + two; };

var result = cdL3("Chandra", "mouli");

Conclusion

I will talk more about Expression trees and LINQ in my next article. Happy programming till then!!!