Object Initializers in C#

In this article, we are going to learn about object initializers in C#, which is a feature introduced in version 3.0 that simplifies code by eliminating the need to write multiple lines of code to initialize an object and its properties.

Let’s learn how to use them and their advantages.

What Are Object Initializers?

Object Initializers provide a shorthand syntax for creating and initializing objects in C#. With object initializers, we can create and set the properties of an object in a single statement:

var product = new Product
{
    Name = "Book",
    Quantity = 15,
    UnitPrice = 17.99m
};

Here, we create a Product object and initialize its Name, Quantity, and UnitPrice properties.

We achieve this using the object initializer syntax, where we use curly braces {} to define the properties we want to set and their corresponding values.

This can be a more concise and convenient way of initializing an object’s state than using constructors. Let’s look at how the same object instantiation would look with a constructor:

var product = new Product();
product.Name = "Book";
product.Quantity = 15;
product.UnitPrice = 17.99m;

In comparison to using object initializers, the code we require to create and initialize an object using constructors can be more verbose. This difference becomes even more pronounced when dealing with nested classes.

It’s important to note that when using an object initializer to initialize a property of a class, the property must still be accessible from the context in which we are using the object initializer. For instance, if the property has a private setter, we can only initialize it from within the class itself.

Advantages of Object Initializers

One of the major advantages of object initializers is simplified object creation. They can reduce the amount of code we need to write.

Instead of writing multiple lines of code to initialize an object and its properties, we can achieve the same result in a single statement. This can help make our code more concise.

In addition, another advantage is that they can improve the readability of the code.

When using object initializers, it’s clear to anyone reading our code what properties we are initializing and what their values are. This can help reduce the likelihood of bugs.

Object initializers also help us achieve enhanced maintainability. 

When using object initializers, it becomes easier to add, modify, or remove properties without having to modify constructors or other parts of the code. This reduces the chances of introducing errors or breaking changes and makes the codebase more maintainable.

Finally, they improve the flexibility of the code by making it easier to modify the initial state of an object.

If a new property is added to an object, it can be easily initialized using an object initializer without needing to modify the constructor. It is particularly useful when working with classes that have a large number of properties or optional properties. Object initializers allow us to initialize only the properties needed, resulting in a more flexible code.

Now, let’s look at how they work with different types of objects.

Object Initializers With Nested Objects

In C#, a nested object is an object that is defined within the scope of another object.

In other words, this means that the nested object is a member of the parent object and we can access it through the parent object’s instance. They allow us to organize related functionality within a single object and improve the modularity and maintainability of the code.

Let’s understand it better by creating a nested class hierarchy:

public class Order
{
    public int OrderId { get; set; }
    public DateTime OrderDate { get; set; }
    public List<Product>? Products { get; set; }
}

Here, we create an Order class with 3 properties, OrderId, OrderDate, and Products. The Products property is itself an instance of a collection of Product we used earlier.

We can use object initializers with nested objects instead of using the traditional method of initializing objects:

var order = new Order
{
    OrderId = 12345,
    OrderDate = DateTime.Now,
    Products = new List<Product>
    {
        new Product
        {
            Name = "Watch",
            Quantity = 2,
            UnitPrice = 999.99m
        },
        new Product
        {
            Name = "Shirt",
            Quantity = 7,
            UnitPrice = 79.99m
        }
    }
};

Here, we’re creating a new instance of the Order class using an object initializer with multiple levels of nesting for the Products property.

Object Initializers With Anonymous Types

Anonymous types allow us to create objects on-the-fly, without the need to first define a specific class. They are called anonymous because the compiler generates a name for the type automatically and we don’t need to name them explicitly.

They are read-only and implicitly typed, meaning that we don’t need to explicitly declare the type of the object we’re creating.

We define anonymous types using the new keyword and an object initializer:

var person = new
{
    FirstName = "Charlie",
    LastName = "Brown",
    Age = 40
};

Here, we’re creating an anonymous type with three properties: FirstName, LastName, and Age. Then, we’re initializing the values of these properties using an object initializer.

Collection Initializers

In C#, we can use object initializers to initialize collections and dictionaries.

They are simply shorthand syntax for initializing properties at the time of creation. When we use them to initialize a collection, we are essentially creating a new instance of the collection and adding elements to it at the same time.

Let’s look at how we can initialize a List<T> using object initializers:

var fruits = new List<string>
{
    "apple",
    "banana",
    "cherry",
    "melon"
};

Here, we create a new instance of a string collection using an object initializer. We can initialize the same list using the Add() method:

var fruits = new List<string>();
fruits.Add("apple");
fruits.Add("banana");
fruits.Add("cherry");
fruits.Add("melon");

The latter results in the same output. However, we can see the initialization in the former example is more concise.

Similarly, we can also initialize a Dictionary<TKey,TValue>:

var numbers = new Dictionary<string, int>
{
    { "one", 1 },
    { "two", 2 },
    { "three", 3 }
};

Expression-Bodied Members

In C#, expression-bodied members are a shorthand syntax for writing methods or properties that consist of a single statement. We can combine them with object initializers to help simplify the initialization of objects even further.

Let’s create a class to see this in action:

public class Person
{
    public string? Name { get; set; }
    public int Age { get; set; }

    public string Description => $"Hi I am {Name}, aged {Age}";
}

Here, we have the Description property defined using an expression-bodied member that returns a string that combines the Name and Age properties. 

We can use object initializer syntax to create a new Person object and set its Name and Age properties. Then, we can access the Description property and print its value to the console:

var person = new Person { Name = "Sam", Age = 30 };
Console.WriteLine(person.Description);

By using expression-bodied members within object initializers, we can define and initialize properties at the same time, making the code more efficient.

When to Use Object Initializers?

One of the most common usages of object initializers is when creating anonymous objects as we saw earlier. This can be useful when we want to quickly encapsulate and pass around data without having to define a named type explicitly.

However, they are particularly useful in a variety of practical applications where concise and readable code is important.

Object initializers prove essential when working with LINQ queries, as they can help simplify the syntax and make the code easier to read and understand:

var products = new List<Product> 
{
    new Product { Name = "Toy", UnitPrice = 5.99m },
    new Product { Name = "Pen", UnitPrice = 7.99m },
    new Product { Name = "Magazine", UnitPrice = 25.99m },
    new Product { Name = "Calculator", UnitPrice = 67.99m },
};

var cheapProducts = products.Where(p => p.UnitPrice < 10.00m)
                    .Select(p => new { p.Name, p.UnitPrice })
                    .ToList();

Here, we’re using object initializers to create a List<Product> and then filter that list using a LINQ query to find all products with a price of less than 10.

Then, we’re using another object initializer to create an anonymous type with just the product name and unit price for each item in the filtered list.

Also, object initializers are useful in testing, as they can help simplify the process of setting up test data:

var order = new Order
{
    OrderId = 12345,
    OrderDate = DateTime.Now,
    Products = new List<Product>
    {
        new Product
        {
            Name = "Watch",
            Quantity = 2,
            UnitPrice = 999.99m
        },
        new Product
        {
            Name = "Shirt",
            Quantity = 7,
            UnitPrice = 79.99m
        }
    }
};

Assert.Equal(12345, order.OrderId);

Here, we’re using object initializers to create an Order object along with it’s Product list for use in a test. 

When testing a class that depends on another class, often it’s necessary to create a mock object with a library such as Moq. This allows us to isolate the behavior being tested. We can use object initializers to quickly create these mock objects with the necessary properties set.

Potential Issues With Object Initializers

There are a few performance overheads and potential pitfalls to keep in mind while using object initializers.

Efficiency When Initializing Complex Objects

A potential inefficiency of using object initializers is related to code repetition. Their extensive use can lead to redundant initialization logic in different parts of the code base, making maintenance and updates more difficult and time-consuming for us. In such cases, object initializers can become less efficient than using constructors.

To understand this, let’s introduce a GetTotalPrice() method in the Product class:

public decimal TotalPrice { get; set; }

public void GetTotalPrice()
{
    TotalPrice = Quantity * UnitPrice;
}

Now, if we use the object initializer approach, we need to account for this initial logic at each instantiation:

var product = new Product
{
    Name = "Book",
    Quantity = 15,
    UnitPrice = 17.99m
};

product.GetTotalPrice();

This means that we need to ensure that we always call the method after creating the object. This is an additional responsibility and can lead to errors if we don’t call the method correctly.

If we use a constructor instead, we can ensure that the object is always correctly initialized as soon as it is created:

public Product(string name, int quantity, decimal unitPrice)
{
    Name = name;
    Quantity = quantity;
    UnitPrice = unitPrice;

    GetTotalPrice();
}

This means that we don’t need to rely on an additional method call, which can reduce the potential for errors in the code.

Compatibility With Immutable Objects

Another potential issue with object initializers is that they may not be compatible with immutable objects.

We can not modify immutable objects after creating them, which means that we can not use object initializers to set their properties:

public class LogisticsPartner
{
    public int Id { get; }
    public string Name { get; }

    public LogisticsPartner(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

Here, we have an immutable class LogisticsPartner. Since there is no public setter for Id and Name properties, object initializer syntax cannot be used to initialize the properties.

Instead, we must use the constructor to initialize the properties:

var partner = new LogisticsPartner(67845, "DHL");

Initialization Order

The order of initialization of properties of a class is essential when using an object initializer. Incorrect initialization order can lead to unexpected behavior in the application.

Let’s understand this better through a new class:

public class Car
{
    public string Make { get; set; }
    public string Model { get; set; }
    public string Description { get; set; }

    public Car(string make, string model)
    {
        Make = make;
        Model = model;
        Description = GetCarDescription();
    }

    private string GetCarDescription()
    {
        return $"This is a {Make} {Model}.";
    }
}

Here, the Car class has a constructor that sets the Make and Model properties and calls the GetCarDescription() method to set the Description property.

Now, let’s see how initialization order affects properties:

var toyota = new Car("Toyota", "Corolla") { Description = "A fairly basic sedan." };

So, during the instantiation of the Car class, the object initializer sets the Description property to “A fairly basic sedan” after the constructor is called. This means that the Description property is initialized twice, first by the constructor and then by the object initializer, and the final value of the property is determined by the order of initialization.

If we don’t involve the object initializer, the Description property is only initialized by the constructor and the GetCarDescription() method is called before any other code has a chance to modify the property:

var honda = new Car("Honda", "Civic");

Hence, this can lead to unexpected behavior if we don’t carefully manage the initialization order.

In this case, the Description property of the toyota object is set to an incorrect value because it is overwritten by the object initializer after the constructor is called.

Performance Considerations

Object initializers can also have a slight performance overhead compared to using constructors directly. This is because they are essentially a shorthand syntax for invoking property setters. It can have additional overhead due to reflection and method calls.

The performance overhead of using object initializers is generally negligible and shouldn’t be a concern for most applications. Nevertheless, we should use constructors when working with more complex initialization logic.

Constructors offer more flexibility than object initializers when it comes to initializing objects. They allow for performing complex validation and setting default values based on specific conditions. In contrast, object initializers are more suitable for simple initialization tasks, like setting default property values or initializing straightforward objects.

Conclusion

In this article, we learned about object initializers in C# and their usage. We saw how using them could reduce the amount of code we need to write, making our code easier to read and understand.

Also, we learned about their versatility where we can use them with anonymous objects, nested objects, collections, and dictionaries. Also, we saw common pitfalls when working with object initializers and how to avoid them.

Ultimately, it’s important to consider the complexity of the initialization logic and the level of flexibility needed when deciding whether to use a constructor or an object initializer.