How can I flatten my data model's JSON output in C#?

Question

If I have a model like this:

public class Person
{
    public string Name { get; set; }
    public DateTime DOB { get; set; }
    public Dictionary<string, string> Address { get; set; }
}

Where the dictionary could have data like

"Number", "18"
"Line1", "Knotta Street"
"Line2", "Thrumpton-on-Thames"
"Postcode", "SW1 2AA"

Is there any way I can flatten an instance of this model to create a new, temporary anonymous object that'd look like this:

Name : Jim
DOB : 21/01/1990
Number : 18
Line1 : Knotta Street
Line2 : Thrumpton-on-Thames
Postcode : SW1 2AA

With the ultimate goal being that I can output it to JSON in that completely flat 1:1 format

Answer 1

You just need to create a flattened dictionary. You can achieve this by manually adding your keys and values for static properties, and then dynamically adding your existing key value pairs in the Address dictionary.

Personally, I recommend creating a method that flattens out the data and gives it back as a JSON string:

public class Person {
    public string Name { get; set; }
    public DateTime DOB { get; set; }
    public Dictionary<string, string> Address { get; set; }
    public string GetFlattenedJson() {
        var result = new Dictionary<string, object> {
            { "Name", Name },
            { "DOB", DOB }
        };
        foreach (var datum in Address)
            result.Add(datum.Key, datum.Value);

        return JsonConvert.SerializeObject(result);
    }
}

Then, when you need the flattened data, you simply access it with that method:

var flatJson = myPerson.GetFlattenedJson();

Answer 2

Clarifying Edit: dynamic objects aren't anonymous objects, I demonstrated with dynamic since it's the closest solution available - a real anonymous object can't have properties populated at runtime based on a dictionary (unless code generation on the fly is introduced), only dynamic objects support that.

---

You need to use dynamic to generate an anonymous object with dynamic properties, usually ExpandoObject is used in such scenarios:

        var person = new Person
        {
            Name = "Jim",
            DOB = DateTime.UtcNow,
            Address = new Dictionary<string, string>
            {
                { "Number", "18" },
                { "Line1", "Knotta Street" },
                { "Line2", "Thrumpton-on-Thames" },
                { "Postcode", "SW1 2AA" },
            }
        };
        dynamic flatterned = new ExpandoObject();
        flatterned.Name = person.Name;
        flatterned.DOB = person.DOB;

        foreach (var kv in person.Address)
        {
            (flatterned as IDictionary<string, object>).Add(kv.Key, kv.Value);
        }

        Console.WriteLine(JsonConvert.SerializeObject(flatterned));

Note that as others have commented, there's no need to create an object then serialized to JSON, but that's what you asked for so I figured it could help showing you.

Answer 3

You can use ExpandoObjects to easily achieve what you are looking for. I wrote an extention method below which will work with your any object. However, it will only flatten Dictionary<string, string> at the moment. Will try to update it later.

public static class ExtentionClasses
{
    public static dynamic Flatten<T>(this T item)
    {
        // Get all the properties not of type dictionary
        var regularProps = item.GetType().GetProperties().Where(x => !typeof(Dictionary<string, string>).IsAssignableFrom(x.PropertyType));
        var dictionaryProps = item.GetType().GetProperties().Where(x => typeof(Dictionary<string, string>).IsAssignableFrom(x.PropertyType));

        var outputDict = new Dictionary<object, object>();

        // Create a dynamic object
        dynamic expando = new ExpandoObject();

        // Add the regular properties
        foreach (var prop in regularProps)
        {
            AddProperty(expando, prop.Name, prop.GetValue(item));
        }

        // Add the dictionary properties
        foreach (var prop in dictionaryProps)
        {
            // convert to dict
            var val = prop.GetValue(item);
            var dict = (Dictionary<string, string>)val;

            foreach(var keyValue in dict)
            {
                AddProperty(expando, keyValue.Key, keyValue.Value);
            }
        }

        return expando;
    }

    public static void AddProperty(ExpandoObject expando, string propertyName, object propertyValue)
    {
        // ExpandoObject supports IDictionary so we can extend it like this
        var expandoDict = expando as IDictionary<string, object>;
        if (expandoDict.ContainsKey(propertyName))
            expandoDict[propertyName] = propertyValue;
        else
            expandoDict.Add(propertyName, propertyValue);
    }
} 

Usage Example:

var person = new Person()
{
    Name = "Jhon",
    DOB = DateTime.Today,
    Address = new Dictionary<string, string>()
    {
        {"Number", "18"},
        {"Line1", "Knotta Street"},
        {"Line2", "Thrumpton-on-Thames"},
        {"Postcode", "SW1 2AA"}
    }
};

var x = person.Flatten();

Console.WriteLine(x.Name);
Console.WriteLine(x.Postcode);

And the results:

Jhon
SW1 2AA

That way you can still reference the object all you want before printing out the Json Result with JsonConvert.SerializeObject(x)