Geeks With Blogs
Gaurav Taneja Great dreams... never even get out of the box. It takes an uncommon amount of guts to put your dreams on the line, to hold them up and say, "How good or how bad am I?" That's where courage comes in.
A Preview of What is New in C# 3.0

On the heels of the Visual Studio 2005 and C# 2.0 releases, Microsoft has
given a sneak preview of what to expect in the version after the next: C#
3.0. Even though C# 3.0 is not even standardized yet, Microsoft provided
a preview release at its Professional Developers Conference (PDC) in
September so eager developers could try out some of the expected features.
This article discusses the following major new enhancements expected in C#

  • Implicitly typed local variables
  • Anonymous types
  • Extension methods
  • Object and collection initializers
  • Lambda expressions
  • Query expressions
  • Expression Trees

Implicitly Typed Local Variables

C# 3.0 introduces a new keyword called "var". Var allows you to declare a
new variable, whose type is implicitly inferred from the expression used to
initialize the variable. In other words, the following is valid syntax in C# 3.0:

var i = 1;

The preceding line initializes the variable i to value 1 and gives it the type of
integer. Note that "i" is strongly typed to an integer—it is not an object or a VB6
variant, nor does it carry the overhead of an object or a variant.

To ensure the strongly typed nature of the variable that is declared with the var
keyword, C# 3.0 requires that you put the assignment (initializer) on the same
line as the declaration (declarator). Also, the initializer has to be an expression,
not an object or collection initializer, and it cannot be null. If multiple declarators
exist on the same variable, they must all evaluate to the same type at compile time.

Implicitly typed arrays, on the other hand, are possible using a slightly different
syntax, as shown below:

var intArr = new[] {1,2,3,4} ;

The above line of code would end up declaring intArr as int[].

The var keyword allows you to refer to instances of anonymous types (described
in the next section) and yet the instances are statically typed. So, when you create
instances of a class that contain an arbitrary set of data, you don't need to predefine
a class to both hold that structure and be able to hold that data in a statically typed

Anonymous Types

C# 3.0 gives you the flexibility to create an instance of a class without having to write
code for the class beforehand. So, you now can write code as shown below:

new {hair="black", skin="green", teethCount=64}

The preceding line of code, with the help of the "new" keyword, gives you a new type
that has three properties: hair, skin, and teethCount. Behind the scenes, the C#
compiler would create a class that looks as follows:

class __Anonymous1
private string _hair = "black";
private string _skin = "green";
private int _teeth = 64;
public string hair {get { return _hair; } set { _hair = value; }}
public string skin {get { return _skin; } set { _skin = value; }}
public int teeth {get { return _teeth; } set { _teeth = value; }}

In fact, if another anonymous type that specified the same sequence of names and
types were created, the compiler would be smart enough to create only a single
anonymous type for both instances to use. Also, because the instances are, as you
may have guessed, simply instances of the same class, they can be exchanged
because the types are really the same.

Now you have a class, but you still need something to hold an instance of the above
class. This is where the "var" keyword comes in handy; it lets you hold a statically
typed instance of the above instance of the anonymous type. Here is a rather simple
and easy use of an anonymous type:

var frankenstein = new {hair="black", skin="green", teethCount=64}

Extension Methods

Extension methods enable you to extend various types with additional static methods.
However, they are quite limited and should be used as a last resort—only where
instance methods are insufficient.

Extension methods can be declared only in static classes and are identified by the
keyword "this" as a modifier on the first parameter of the method. The following is
an example of a valid extension method:

public static int ToInt32(this string s)
return Convert.ToInt32(s) ;

If the static class that contains the above method is imported using the "using" keyword
, the ToInt32 method will appear in existing types (albeit in lower precedence to existing
instance methods), and you will be able to compile and execute code that looks as follows:

string s = "1";
int i = s.ToInt32();

This allows you to take advantage of the extensible nature of various built-in or defined
types and add newer methods to them.

Object and Collection Initializers

C# 3.0 is expected to allow you to include an initializer that specifies the initial values
of the members of a newly created object or collection. This enables you to combine
declaration and initialization in one step.

For instance, if you defined a CoOrdinate class as follows:

public class CoOrdinate
public int x ;
public int y;

You then could declare and initialize a CoOrdinate object using an object initializer,
like this:

var myCoOrd = new CoOrdinate{ x = 0, y= 0} ;

The above code may have made you raise your eyebrows and ask, "Why not just write
the following:"

var myCoOrd = new CoOrdinate(0, 0) ;
Note: I never declared a constructor that accepted two parameters in my class.
In fact, initializing the object using an object initializer essentially is equivalent to
calling a parameterless (default) constructor of the CoOrdinate object and then assigning the relevant values.

Similarly, you should easily be able to give values to collections in a rather concise and
compact manner in C# 3.0. For instance, the following C# 2.0 code:

List<string> animals = new List<string>();

Now can be shortened to simply:

List<string> animals = new List<string> {
"monkey", "donkey", "cow", "dog", "cat" } ;

Lambda Expressions: The Espresso of Anonymous Methods

C# 1.x allowed you to write code blocks in methods, which you could invoke
easily using delegates. Delegates are definitely useful, and they are used
throughout the framework, but in many instances you had to declare a method
or a class just to use one. Thus, to give you an easier and more concise way
of writing code, C# 2.0 allowed you to replace standard calls to delegates
with anonymous methods. The following code may have been written in .NET 1.1
or earlier:

class Program
delegate void DemoDelegate();
static void Main(string[] args)
DemoDelegate myDelegate = new DemoDelegate(SayHi);
void SayHi()
Console.Writeline("Hiya!!") ;

In C# 2.0, using anonymous methods, you could rewrite the code as follows:

class Program
delegate void DemoDelegate();
static void Main(string[] args)
DemoDelegate myDelegate = delegate()

Whereas anonymous methods are a step above method-based delegate invocation,lambda expressions allow you to write anonymous methods in a more concise, functional syntax. 

You can write a lambda expression as a parameter list, followed by the => token,followed by an expression or statement block. The above code can now be replaced with the following code:

class Program
delegate void DemoDelegate();
static void Main(string[] args)
DemoDelegate myDelegate = () => Console.WriteLine("Hiya!!") ;

Although Lambda expressions may appear to be simply a more concise way of writing anonymous methods, in reality they also are a functional superset
of anonymous methods. Specifically, Lambda expressions offer the following functionality:

  • They permit parameter types to be inferred. Anonymous methods will require you to explicitly state each and every type.
  • They can hold either query expressions (described in the following section) or C# statements.
  • They can be treated as data using expression trees (described later).This cannot be done using Anonymous methods.


Query Expressions

Even though further enhancements may be introduced in the coming months as C# 3.0 matures, the new features described in the preceding sections make it a lot easier to work with data inside C# in general. This feature, also known as LINQ (Language Integrated Query), allows you to write
SQL-like syntax in C#.For instance, you may have a class that describes your data as follows:


public class CoOrdinate

public int x ; public int y; }

You now could easily declare the logical equivalent of a database table inside C# as follows:

// Use Object and collection initializers
List<CoOrdinate> coords = ... ;

And now that you have your data as a collection that implements
IEnumerable<T>, you easily can query this data as follows:

var filteredCoords =
from c in coords
where x == 1
select (c.x, c.y)

In the SQL-like syntax above, "from", "where", and "select" are query expressions that take advantage of C# 3.0 features such as anonymous types, extension methods, implicit typed local variables, and so forth.

This way, you can leverage SQL-like syntax and work with disconnected data easily.

Each query expression is actually translated into a C#-likeinvocation behind the scenes. For instance, the following:

where x == 1

Translates to this:

coords.where(c => c.x == 1)
As you can see, the above looks an awful lot like a lambda expression and extension method. C# 3.0 has many other query expressions and rules 
that surround them.


Expression Trees

C# 3.0 includes a new type that allows expressions to be treated as data at runtime.This type, System.Expressions.Expression<T>, is simply an in-memory representation of a lambda expression. The end result is that your code can modify and inspect lambda expressions at runtime.

The following is an example of an expression tree:

Expression<DemoDelegate> filter = () => Console.WriteLine("Hiya!!") ;            

With the above expression tree setup, you easily can inspect the contents of the tree by using various properties on the filter variable.

One to Grow On


C# 3.0 offers incredible new features that make your work as an application developer and architect a lot easier, and yet it remains a programming
language that lends itself to stricter and cleaner architecture.

C# 3.0 is in its infancy right now and it will mature in the coming months, but given the sizable impact its changes will have on the surrounding .NET
Framework, its recommended architecture, and design patterns, definitely
keep your eye on it.


Posted on Tuesday, April 1, 2008 11:24 PM .Net 3.0 | Back to top

Comments on this post: Features in .Net 3.0

# re: Features in .Net 3.0
Requesting Gravatar...
It's really useful for our software company.and its really greatfull
Left by pardhu on Jan 24, 2010 10:50 PM

# re: Features in .Net 3.0
Requesting Gravatar...
Very Nice article which help me to understand basic feateures of .net 3.0
Left by UMESH on Jan 27, 2011 10:06 PM

# re: Features in .Net 3.0
Requesting Gravatar...
Nice post...As a beginner, I really could not expect an explanation this far. Really nice write-up.

Left by VVR on Jul 23, 2011 2:16 PM

Your comment:
 (will show your gravatar)

Copyright © Gaurav Taneja | Powered by: