Dynamically Adding Properties to Objects in C#: Using ExpandoObject and dynamic

Background on Dynamic Object Properties

In traditional object-oriented programming, object properties are typically fixed at compile-time through class definitions. For example, in C#, a Person class might include properties like FirstName, LastName, Dob, and Address. However, in real-world development, scenarios often arise where properties need to be added dynamically at runtime. For instance, a user might want to temporarily add Age or Sex properties to a person object, with property names that may change over time and cannot be hardcoded in advance. This need is common in applications such as data processing, configuration management, or dynamic UI generation.

Solution with ExpandoObject and dynamic

C# provides the ability to add properties dynamically through the ExpandoObject class and the dynamic keyword. ExpandoObject, part of the System.Dynamic namespace, allows properties to be added, removed, or modified at runtime, behaving similarly to a dictionary. The dynamic keyword bypasses compile-time type checking, enabling flexible property access.

Here is a basic example demonstrating how to create a dynamic object and add properties:

dynamic person = new ExpandoObject();
person.FirstName = "Sam";
person.LastName = "Lewis";
person.Age = 42;
person.Foo = "Bar";

In this example, the person object initially has no predefined properties. Through assignment operations, FirstName, LastName, Age, and Foo are dynamically added to the object. Attempting to read a non-existent property, such as person.NonExistent, will throw a RuntimeBinderException, consistent with dictionary key access behavior.

Internal Mechanisms of ExpandoObject

ExpandoObject implements the IDictionary<string, object> interface, meaning it is essentially a key-value pair collection where keys are property names and values are property values. When properties are accessed using dynamic, C#'s Dynamic Language Runtime (DLR) translates these operations into dictionary read/write calls. For example, person.Age = 42 is equivalent to ((IDictionary<string, object>)person)["Age"] = 42 under the hood.

This design makes ExpandoObject highly flexible but introduces some performance overhead, as each property access requires runtime binding. The following code illustrates explicit use of the dictionary interface:

dynamic person = new ExpandoObject();
var dict = (IDictionary<string, object>)person;
dict["Age"] = 42;
Console.WriteLine(person.Age); // Output: 42

Advantages and Disadvantages of Dynamic Properties

The primary advantage of using ExpandoObject is its flexibility. It is suitable for scenarios where properties are uncertain or change frequently, such as parsing JSON data, building dynamic queries, or handling user-defined fields. Additionally, it can simplify code by avoiding the need to create multiple class definitions for temporary data.

However, this approach has drawbacks. First, the lack of compile-time type checking means errors may only surface at runtime, increasing debugging difficulty. Second, performance is inferior to static typed objects due to the overhead of dynamic binding. Finally, overuse of dynamic features can reduce code readability and maintainability.

Practical Applications and Best Practices

Dynamic objects are widely used in web development, data serialization, and plugin systems. For example, in ASP.NET Core, ExpandoObject is often used to dynamically build view models or handle API responses. Here is an example combining JSON processing:

using System.Dynamic;
using Newtonsoft.Json;

dynamic config = new ExpandoObject();
config.Setting1 = "Value1";
config.Setting2 = 123;
string json = JsonConvert.SerializeObject(config);
Console.WriteLine(json); // Output: {"Setting1":"Value1","Setting2":123}

To balance flexibility with safety, it is recommended to use dynamic properties in cases where property names come from external inputs (e.g., user configurations or database fields) and cannot be predefined, or during prototyping for rapid iteration. In other scenarios, prefer static types or alternatives like dictionaries.

Comparison with Other Methods

Beyond ExpandoObject, other methods in C# for implementing dynamic properties include using Dictionary<string, object> or reflection. Dictionaries offer similar key-value storage but with more verbose syntax; reflection allows manipulation of existing object properties but suffers from poor performance and complex code. ExpandoObject strikes a good balance between ease of use and functionality, particularly for scenarios requiring dynamic behavior with infrequent access.

In summary, ExpandoObject and dynamic provide C# developers with a powerful tool for handling runtime dynamic properties. By understanding their principles and appropriate use cases, developers can effectively apply this feature in projects to enhance code adaptability and scalability.