Collection initializers use object initializers to initialize their object collection. By using a collection initializer, we do not have to initialize objects by having multiple calls. For example, in the Anonymous Types section a little earlier, we created a list named icecreamsList which is a collection of Icecreams. All Icecream objects added to the collection are initialized using the collection initializer, as follows:

List<Icecream> icecreamsList = new List<Icecream>
{
new Icecream
{
Name="Chocolate Fudge Icecream",
Ingredients="cream, milk, mono and diglycerides...",
Cholesterol="50mg",
Protein="4g",
TotalCarbohydrates="35g",
TotalFat="20g",
Price=10.5
},
new Icecream
{
Name="Vanilla Icecream",
Ingredients="vanilla extract, guar gum, cream...",
Cholesterol="65mg",
Protein="4g",
TotalCarbohydrates="26g",
TotalFat="16g",
Price=9.80
},
new Icecream
{
Name="Banana Split Icecream",
Ingredients="Banana, guar gum, cream...",
Cholesterol="58mg",
Protein="6g",
TotalCarbohydrates="24g",
TotalFat="13g",
Price=7.5
}
};

Microsoft introduced the concept of partial classes in .NET 2.0, which allows multiple developers to work on the same class file at the same time. This feature provides a way to split the definition of a class in multiple files. All these files are combined at the time of compilation. This is very helpful in adding new code or new functionality to the class without disturbing the existing class files; partial is a keyword modifier used for splitting the class.

Partial method is a new feature introduced in .NET 3.0 which is similar to partial classes. Partial methods are a part of partial classes, where the implementer of one part of the class just defines the method, and the other implementer can implement the method. It is not necessary that the second implementer of the class has to implement the method. If the method is not implemented, the compiler removes the method signature and all the calls to this method. This helps the developer to customize the code with his own implementation. It is safe to declare the partial methods without worrying about the implementation. The compiler will take care of removing all the calls to the method. Following is an example for defining and implementing partial methods:

// Defining UpdateItemsList method in Items1.cs file
partial void UpdateItemsList();
//Implemeting UpdateItemsList method in Items2.cs file
partial void UpdateItemsList()
{
// The method Implementation goes here
}

There are some constraints in using partial methods. They are as follows:

Anonymous methods in C# 2.0 help us to avoid declaring a named method by writing methods inline with code. This can be used in places where we need the functionality only within the parent method. We cannot reuse the anonymous method code in the other methods, as it is available within the parent method. Following is an example for finding a particular string from a list of strings:

class Program
{
static void Main(string[] args)
{
List<string> icecreamList = new List<string>();
icecreamList.Add("Chocolate Fudge Icecream");
icecreamList.Add("Vanilla Icecream");
icecreamList.Add("Banana Split Icecream");
icecreamList.Add("Rum Raisin Icecream");
string vanilla = icecreamList.Find(FindVanilla);
Console.WriteLine(vanilla);
}
public static bool FindVanilla(string icecream)
{
return icecream.Equals("Vanilla Icecream");
}
}

The equivalent anonymous method for the above code would be as follows:

List<string> icecreamList1 = new List<string>();
icecreamList1.Add("Chocolate Fudge Icecream");
icecreamList1.Add("Vanilla Icecream");
icecreamList1.Add("Banana Split Icecream");
icecreamList1.Add("Rum Raisin Icecream");
string vanilla1 = icecreamList1.Find(delegate(string icecream)
{
return icecream.Equals("Vanilla Icecream");
});
Console.WriteLine(vanilla1);

In the previous example, a method is defined inline and we do not have any external method to find the string.

Now C# 3.0 has a new feature called lambda expression which helps us to avoid the anonymous methods itself. For example, here is the equivalent method with lambda expression for the previous anonymous method.

// Using Lambda Expressions
List<string> icecreamList2 = new List<string>();
icecreamList2.Add("Chocolate Fudge Icecream");
icecreamList2.Add("Vanilla Icecream");
icecreamList2.Add("Banana Split Icecream");
icecreamList2.Add("Rum Raisin Icecream");
string vanilla2 = icecreamList2.Find((string icecreamname)
=>icecreamname.Equals("Vanilla Icecream"));
Console.WriteLine(vanilla2);

A lambda expression is the lambda with the expression on the right side.

(input parameters separated by commas) => expression

We can also specify the types of the input paramaters; for example, (int x, int y) => x > y.

There is another type called statement lambda that consists of a number of statements enclosed in curly braces.

The following is an example of lambda expression with an extension method. It uses the where extension method to get the total number of integers, and the list of integers (which are less than 10) in the array of integers.

var numbers = new int[] { 1, 10, 20, 30, 40, 5, 8, 2, 9};
var total = numbers.Where(x => x < 10);
Console.WriteLine("Numbers less than ten: " + total.Count());
foreach(var val in total)
Console.WriteLine(val);

LINQ provides the ability to treat expressions as data at runtime using the new type Expression<T> which represents an expression tree. This is an in-memory representation of the lambda expression. Using this, we can modify the lambda expressions through code. By getting these expressions as data, we can also build the query statements at runtime. System.Expressions is the namespace used for this. There are some limitations to the lambdas. They are as follows:

Currently, we are actually working with two different languages when we retrieve data from the database and work with our front-end applications. One would be for front-end application development and the other is the SQL for retrieving data from the database. These SQL queries are embedded into the application code as strings, so we don't get the facility of the compiler checking the query statements in quotes.

In C# 3.0, we have LINQ which gives the benefit of strong type checking. Also, we don't need to depend on SQL queries and writing it within quotes. LINQ is similar to relational database queries. Query expressions provide the language integrated syntax for queries.

The query expression begins with a from clause and ends with a select or a group clause. The from clause can be followed by many from, let, or where clauses.The from clause is a generator, the let clause is for computing the value, the where clause is for filtering the result and select or group specifies the shape of the result. There are other operators like orderby. For example, the query below is to select ice-creams with price less than 10.

from Icecream Ice in Icecreams
where Ice.Price <= 10.0
select Ice

Following are the syntax for the query expressions:

query-expression:

from-clause query-body

from-clause:

from typeopt identifier in expression join-clausesopt

join-clauses:

join-clause

join-clauses join-clause

join-clause:

join typeopt identifier in expression on expression equals expression

join typeopt identifier in expression on expression equals expression into identifier

query-body:

from-let-where-clausesopt orderby-clauseopt select-or-group-clause query- continuationopt

from-let-where-clauses:

from-let-where-clause

from-let-where-clauses from-let-where-clause

from-let-where-clause:

from-clause

let-clause

where-clause

let-clause:

let identifier = expression

where-clause:

where boolean-expression

orderby-clause:

orderby orderings

orderings:

ordering

orderings , ordering

ordering:

expression ordering-directionopt

ordering-direction:

ascending

descending

select-or-group-clause:

select-clause

group-clause

select-clause:

select expression

group-clause:

group expression by expression

query-continuation:

into identifier join-clauses_opt query-body

C# 3.0 actually translates the query expressions into invocation of methods like where, select, orderby, groupby, thenby, selectmany, join, cast, groupjoin that have their own signatures and result types. These methods implement the actual query for execution. The translation happens as a repeated process on the query expressions, until no further translation is possible. For example, the following query:

from Icecream Ice in Icecreams
where Ice.Cholestrol == "2mg"
select Ice

...is first translated into:

from Icecream Ice in Icecreams.Cast<Icecream>()
where Ice.Cholestrol == "2mg"
select Ice

...the final translation would be as follows:

Icecreams.Cast<Icecream>().Where(Ice => Ice.Cholestrol == "2mg")

The following query:

from Ice in Icecreams
group Ice.Name by Ice.Cholestrol

...is translated into the following:

Icecreams.GroupBy(Ice => Ice.Cholestrol, Ice =>Ice.Name

Let us see how we can make use of these queries with in-memory collections. The System.Linq namespace has all the standard query operators. We have to use this namespace for writing queries. Create a class, Icecream as follows:

public class Icecream
{
public string name;
public string ingredients;
public string totalFat;
public string cholesterol;
public string totalCarbohydrates;
public string protein;
public double price;
}

Using the above Icecream class, create list of ice-creams and assign that to a list variable. We will see how we can easily retrieve information from this list using queries.

List<Icecream> icecreamsList = new List<Icecream>
{
new Icecream("Chocolate Fudge Icecream", "cream, milk, mono and
diglycerides...", "20g", "50mg", "35g", "4g", 10.5),
new Icecream ("Vanilla Icecream", "vanilla extract, guar gum,
ream...", "16g", "65mg", "26g", "4g", 9.80 ),
new Icecream ("Banana Split Icecream", "Banana, guar gum,
cream...", "13g", "58mg", "24g", "6g", 7.5)
};

The following query will return the name and price of the ice-creams with a price less than or equal to 10. In this query we have not specified any type for variables; it's all implicit. Even if we want to specify the type, it is not easy to identify the type of the value returned for the query.

var icecreamswithLeastPrice =
from Ice in icecreamsList
where Ice.price <= 10
select new { Ice.name, Ice.price };
Console.WriteLine("Icecreams with least price: ");
foreach (var ice in icecreamswithLeastPrice)
{
Console.WriteLine(ice.name + " " + ice.price);
}

Let us see how we can leverage the feature of lambda expressions here. For example, we will find out the list of ice-creams with a lower price using the lambda expressions. Include the following code to the main method of the program after creation of the icecreamsList.

var count = icecreamsList3.Count<Icecream>(Ice => Ice.price <=0);
Console.WriteLine("Number of Icecreams with price
less than ten: {0} ", count);

The above lambda expression will return the total number of ice-creams with a price less than or equal to 10.

Expression trees are an in-memory representation of a lambda expression. Using this we can modify and inspect the lambda expressions at runtime using expression trees in the System.Linq.Expressions namespace. Lambda expressions are compiled as code or data, depending on the context they are used in. If we assign a lambda expression to a variable of type delegate, then the compiler will generate the corresponding executable code; but we assign the lambda expression to a variable of the generic type Expression<T>, so the compiler won't create the executable code, but will generate an in-memory tree of objects that represents the structure of the expression. These structures are known as expression trees.

For example, consider the following lambda expression using delegate:

Func<int, int> func = x => x + 5;

This code is compiled as executable and can be executed as follows:

var three = func(1);

The same delegate is no longer compiled as executable, but compiled as data if we define the delegate as expression tree:

Expression<Func<int, int>> expression = func => x + 5;

To use this expression in the application, it has to be compiled and invoked as follows:

var originalDelegate = expression.Compile();
var three = originalDelegate.Invoke(2);

Each node in the expression tree represents an expression. If we decompose the expression, we can find out how the expression tree represents the lambda expressions. Following is the sample code to decompose the previous expression:

ParameterExpression parameter =
ParameterExpression)expression.Parameters[0];
BinaryExpression operation = (BinaryExpression)expression.Body;
ParameterExpression left = (ParameterExpression)operation.Left;
ConstantExpression right = (ConstantExpression)operation.Right;
Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",
parameter.Name, left.Name, operation.NodeType, right.Value);

The output of the above decomposition would be:

Decomposed expression: func => func Add 5

Expression trees are implemented in the System.Query.dll assembly under the System.Linq.Expressions namespace. The abstract class Expression provides the root of a class hierarchy used to model expression trees. The Expression class contains static factory methods to create expression tree nodes of various types.

There are many different abstract classes used to represent the different types of elements in an expression. These classes are derived from the non-generic version of Expression. The following table examines some abstract classes derived from the Expression class.