One-Step Object Creation and Initialization in C# 3.0

C# 3.0 introduced object initializers, which ease construction and initialization of objects. An object initializer contains the values that the members of a newly created object should be assigned. It specifies values for one or more fields or properties of the object.

An object initializer has the following properties:

  • It consists of a sequence of member initializers, enclosed by "{" and "}" tokens and separated by commas.
  • Each member initializer can name only an accessible field or property of the object being initialized, followed by an equal sign (=) and an expression of the value (V) or an object initializer.
  • A member initializer that specifies an expression of value (V), as above, is processed in the same way as an assignment to the field or property.
  • A member initializer that specifies an object initializer after the equal sign is an initialization of an embedded object. The assignments in the object initializers are treated as assignments to members of the field or property. Value type properties cannot be initialized using this mechanism.

If an object-creation expression includes an object or collection initializer, it can omit the constructor argument list and enclosing parenthesis. Omitting the constructor argument list and the enclosing parenthesis is equivalent to specifying an empty argument list.

An object-creation expression is executed in two steps:

  1. Invoke an instance constructor, which creates the object.
  2. Perform member initialization using the values specified in the object initializers. (An object initializer cannot refer to the object being initialized.)

The object initializer first invokes the object's parameterless constructor and then initializes the named fields to the specified values. Fields that are not specified will have the default values.

Example of Object Initializers

Suppose you have an entity Student, who can be identified by First Name and Last Name. You also have an entity ScienceClass, which is composed of three such students. This scenario can be represented with the following C# 3.0:

using System;
using System.Collections.Generic;
using System.Text;
using System.Query;
using System.Xml.XLinq;
using System.Data.DLinq;

namespace ObjectInitializers
   class Program
      public class Student
         public string firstName;
         public string lastName;

      public class ScienceClass
         public Student Student1, Student2, Student3;
      static void Main(string[] args)
         var student1 = new Student{firstName = "Bruce",
                                    lastName  = "Willis"};
         var student2 = new Student{firstName = "George",
                                    lastName  = "Clooney"};
         var student3 = new Student{firstName = "James",
                                    lastName  = "Cameron"};

         var sClass = new ScienceClass{Student1 = student1,
                                       Student2 = student2,
                                       Student3 = student3};

If you have Visual Studio 2005 (any flavor) and the LINQ Preview installed, you can compile the above code in your IDE.

If you do not have VS 2005, but have the LINQ Preview installed, you can compile the code from the command line using the following command:

C:\Program Files\LINQ Preview\Bin\Csc.exe
/reference:"C:\Program Files\LINQ Preview\Bin\System.Data.DLinq.dll"
/reference:"C:\Program Files\LINQ Preview\Bin\System.Query.dll"
/reference:"C:\Program Files\LINQ Preview\Bin\System.Xml.XLinq.dll"

Code Internals

Consider the following code snippet:

var student1 = new Student{firstName = "Bruce",
                           lastName  = "Willis"};
var student2 = new Student{firstName = "George",
                           lastName  = "Clooney"};
var student3 = new Student{firstName = "James",
                           lastName  = "Cameron"};
var sClass = new ScienceClass{Student1 = student1,
                              Student2 = student2,
                              Student3 = student3};

This snippet has the same effect to the compiler as the following:

var sClass = new ScienceClass();

var student1 = new Student();
student1.firstName = "Bruce";
student1.lastName  = "Willis";

var student2 = new Student();
student2.firstName = "George ";
student2.lastName  = "Clooney";

var student3 = new Student();
student3.firstName = "James";
student3.lastName  = "Cameron";

sClass.Student1 = student1;
sClass.Student2 = student2;
sClass.Student3 = student3;

If you fire up ILDASM and open up the compiled binary, you will see something like Figure 1.

Figure 1. Compiled Binary of Sample Code Snippet

If you double-click the Main node in the ILDASM, you will see the following code listing:

.method private hidebysig static void Main(string[] args) cil managed
   // Code size 146 (0x92)
  .maxstack 2
   .locals init ([0] class ObjectInitializers.Program/Student student1,
                 [1] class ObjectInitializers.Program/Student student2,
                 [2] class ObjectInitializers.Program/Student student3,
                 [3] class ObjectInitializers.Program/
                     ScienceClass sClass,
                 [4] class ObjectInitializers.Program/Student
                 [5] class ObjectInitializers.Program/Student
                 [6] class ObjectInitializers.Program/Student
                 [7] class ObjectInitializers.Program/ScienceClass
   IL_0000: nop
   IL_0001: nop
   IL_0002: newobj instance void ObjectInitializers.Program/
   IL_0007: stloc.s '<tampa>f__0'
   IL_0009: ldloc.s '<tampa>f__0'
   IL_000b: ldstr"Bruce"
   IL_0010: stfld string ObjectInitializers.Program/Student::firstName
   IL_0015: ldloc.s '<tampa>f__0'
   IL_0017: ldstr "Willis"
   IL_001c: stfld string ObjectInitializers.Program/Student::lastName
   IL_0021: ldloc.s '<tampa>f__0'
   IL_0023: nop
   IL_0024: stloc.0
   IL_0025: nop
   IL_0026: newobj instance void ObjectInitializers.Program/
   IL_002b: stloc.s '<tampa>f__1'
   IL_002d: ldloc.s '<tampa>f__1'
   IL_002f: ldstr "George"
   IL_0034: stfld string ObjectInitializers.Program/Student::firstName
   IL_0039: ldloc.s '<tampa>f__1'
   IL_003b: ldstr "Clooney"
   IL_0040: stfld string ObjectInitializers.Program/Student::lastName
   IL_0045: ldloc.s '<tampa>f__1'
   IL_0047: nop
   IL_0048: stloc.1
   IL_0049: nop
   IL_004a: newobj instance void ObjectInitializers.Program/
   IL_004f: stloc.s '<tampa>f__2'
   IL_0051: ldloc.s '<tampa>f__2'
   IL_0053: ldstr "James"
   IL_0058: stfld string ObjectInitializers.Program/Student::firstName
   IL_005d: ldloc.s '<tampa>f__2'
   IL_005f: ldstr Cameron"
   IL_0064: stfld string ObjectInitializers.Program/Student::lastName
   IL_0069: ldloc.s '<tampa>f__2'
   IL_006b: nop
   IL_006c: stloc.2
   IL_006d: nop
   IL_006e: newobj instance void ObjectInitializers.Program/
   IL_0073: stloc.s '<tampa>f__3'
   IL_0075: ldloc.s '<tampa>f__3'
   IL_0077: ldloc.0
   IL_0078: stfld class ObjectInitializers.Program/
   IL_007d: ldloc.s '<tampa>f__3'
   IL_007f: ldloc.1
   IL_0080: stfld class ObjectInitializers.Program/
      Student ObjectInitializers.Program/ScienceClass::Student2
   IL_0085: ldloc.s '<tampa>f__3'
   IL_0087: ldloc.2
   IL_0088: stfld class ObjectInitializers.Program/
      Student ObjectInitializers.Program/ScienceClass::Student3
   IL_008d: ldloc.s '<tampa>f__3'
   IL_008f: nop
   IL_0090: stloc.3
   IL_0091: ret
} // end of method Program::Main

One-Step Object Creation and Initialization in C# 3.0

You can also have embedded initialization in ScienceClass, but you will need to declare your ScienceClass a little differently, as shown below:

public class ScienceClass
      Student s1 = new Student();
      Student s2 = new Student();
      Student s3 = new Student();
      public Student Student1
            return s1;
            s1 = value;
      public Student Student2
            return s2;
            s2 = value;
      public Student Student3
            return s3;
      s3 = value;


One-Step Object Creation and Initialization

Object initializers provide a new syntax to initialize the objects you create. This simple syntax combines object creation and initialization into a single step.

About the Author

Vipul Patel is a Microsoft MVP (two years in a row) in Visual C# and currently works at Microsoft through Volt Information Sciences. He specializes in C# and deployment issues. You can reach him at

About the Author

Vipul Vipul Patel

Vipul Patel is a Software Engineer currently working at Microsoft Corporation, working in the Office Communications Group and has worked in the .NET team earlier in the Base Class libraries and the Debugging and Profiling team. He can be reached at



  • There are no comments yet. Be the first to comment!

Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • As all sorts of data becomes available for storage, analysis and retrieval - so called 'Big Data' - there are potentially huge benefits, but equally huge challenges...
  • The agile organization needs knowledge to act on, quickly and effectively. Though many organizations are clamouring for "Big Data", not nearly as many know what to do with it...
  • Cloud-based integration solutions can be confusing. Adding to the confusion are the multiple ways IT departments can deliver such integration...

Most Popular Programming Stories

More for Developers

RSS Feeds

Thanks for your registration, follow us on our social networks to keep up-to-date