In this post I will wrap up some of the smaller but very useful new features of .NET
3.5/C# 3.0. Other features of .NET 3.5 I've already covered are Extension
Methods and Lambda
Expressions.
Object and Collection Initializers
This feature makes it easier to create objects and assign values to the properties
of the objects. Until .NET 3.5 you either had to write code that created an object
and initialized each property of the object, or use a constructor that takes a list
of parameters (which had to change of be overloaded when a property was added). The
same is true for creating lists of object, calling the Add method for every new object.
The following example shows that object and collection initializers makes this easier,
without the use of parameter constructors:
persons
=
new
List
<
Person
>
{
new
Person
{ Name
=
"
Person
I
"
},
new
Person
{ Name
=
"
Person
II
"
},
new
Person
{ Name
=
"
Person
III
"
},
new
Person
{ Name
=
"
Person
IV
"
} };
In the example above the default constructor (without parameters) of Person will be
used, witch will be executed before the property initialization. In case an alternative
constructor is required, e.g. including a read only Id, the following syntax
can be used:
Person
person
=
new
Person(
"
NewGuid
"
)
{ Name
=
"
Person
"
};
Automatic Property get/set
The feature of automatic property takes away the burden of explicitly coding
a private field and the get/set of a property, these are generated
automatically by the compiler. The syntax is similar to the way of defining an abstract
property or a property in an interface:
public
class
Person
{
public
string
Name
{
get
;
set
;
} }
If necessary the get/set can be changed to limit accessibility, e.g. Name
{ get; private set; }. Of course the object initializers as explained above cannot
be used outside the class anymore.
Implicitly Typed Local Variables and Arrays
With implicitly typed variables the type of the variable is not defined up front but
inferred by the compiler using the initialization of the variable. Basically this
looks the same as defining the variable as an object, but there is a huge difference:
after initialization the type is fixed and cannot be changed, e.g. by assigning a
value of another type.
var
a
=
5
;
//
int
var
b
=
5.5
;
//
double
var
c
=
a
+
b;
//
double
var
d
=
new
int
[]
{
1
,
2
};
//
int
array
var
e
=
new
[]
{
1
,
2
};
//
implicitly
typed int array
foreach
(var
f
in
e) Console.WriteLine(f);
Using the var keyword is only allowed for local variables, they cannot be used as
class variables for example. Also, they have to be initialized when they are
declared.
The usage of implicitly typed variables as aboveis a bit doubtful I think, in fact it
does make the code less readable (although IntelliSense can help you out). In relation
to LINQ and Anonymous Types it does make more sense though, but more on that later.
Anonymous Types
Anonymous Types are objects that are defined and created on the fly
using object initializers. The compiler actually creates properties of the
initializers which can be used later on. The name of the type remains unknown
and cannot be used within the program.
var
p1
=
new
{
Name
=
"
Person
I
"
, City
=
"
New
York
"
}; Console.WriteLine(
string
.Format(
"
{0}
from {1}
"
,
p1.Name, p1.City));
Like implicitly Typed Variables the usage of Anonymous Types in this context doesn't
seem to be very useful because you really cannot do much with such
an object. With LINQ the usage will be more frequent, e.g. to display a selection
from an executed query:
var
nyPersons
=
from
q
in
persons
where
q.Address.City
==
"
New
York
"
select
new
{
Name
=
q.Name,
City
=
q.Address.City
};
foreach
(var
nyp
in
nyPersons)
Console.WriteLine(
string
.Format(
"
{0}
from {1}
"
,
nyp.Name, nyp.City));
The source code of these examples can be downloaded from here: TypesVariablesAndInitDemo.zip
(,95 KB)
