C# 3.0 Features: Object Initializers

C# 3.0 is just around the corner so I thought I'd start writing about a few of the features that it exposes and provide quick and concise examples of how they can be used.  Many of the new features rely on the compiler to generate code that you would have had to write in the past. This can result in significantly less code compared to C# 2.0 syntax in many cases.  Here's a list of some of the key features available in C# 3.0:

  • Object Initializers
  • Anonymous Types
  • Automatic Properties
  • Extension Methods
  • Lambda Expressions
  • LINQ
  • Collection Initializers

In this post I'll discuss the fundamentals of object initializers in C# 3.0.  To get started, let's look at the standard way of initializing an object with data in C# 2.0 using constructors.  The following example creates a Person object and passes three values to its constructor.

Person p = new Person("John", "Doe", "602-123-1234");

As mentioned, C# 3.0 now supports the concept of "object initializers" which means you can easily assign data to specific properties in a type with having to create an explicit constructor (you can of course still create constructors as well). The standard C# { and } brackets are used to create object initializers.  Here's an example of using an object initializer to assign property data to a Person type.  It's nice because doing the same thing without using a constructor in C# 2.0 would have resulted in around 5 lines of code which is too many for something simple like property value assignments.

Person p = new Person() {FirstName="John",LastName="Doe",Phone="602-123-1234",City="Phoenix"};

If the Person type defines a sub object as a property you can even use object initializers to create the sub object. Here's an example of defining an Address object:

Person p = new Person()
    FirstName = "John",
    LastName = "Doe",
    Address = new Address()
        Street = "1234 St.",
        City = "Phoenix"

If you've used JavaScript Object Notation (normally referred to as JSON) in AJAX or other client-side applications, you'll recognize this style of syntax.  It's simple, compact, and easy to use.  Although I formatted the example above onto multiple lines to maximize readability, it could certainly be compacted quite a bit if desired. 

In the next post I do on C# 3.0 features I'll cover anonymous types and explain how they answer a question I'm often asked in .NET language classes I teach:  "Why do I have to define a type name twice when creating an object?".

comments powered by Disqus


  • I believe the idea of a constructor is to give consumers of your class a clear picture as to the essential information (often properties) that are required to use your object. The fact they set the properties for you is more of a side-effect.

    There must be a risk that object initializers will mean some developers won't see the point in providing constructors and tell people just to set the properties which will leave consumers wondering which properties are essential and which are optional.


  • Damien,

    I agree with you. It's up to the developer though to decide if they want to provide constructors or not and to know what's best for essential properties. This feature will definitely make it more difficult for developers to know whether or not constructors should be used or not. I completely agree with what you're saying. However, it's a very useful and productive feature that certainly doesn't stop the use of constructors.

Comments have been disabled for this content.