Question

I have JSON data like shown below. I only included column names once to save data size. Please let me know how do I convert this to C# object list.

// JSON
{
    "COLUMNS": [
        "id", "country","lastname", "firstname", "email", "category"
    ], 
    "DATA": [
        [43, "USA", "jon", "doe", "[e-mail]", "HR"], 
        [44, "JAPAN", "tanaka", "yidi", "[e-mail]", "IT"]
    ]
}

// .NET
Employee emp = JsonConvert.DeserializeObject<Employee>(jsonData);  

I should be able to access object properties like emp.lastname.

Also, as the title indicates, I am using the JsonConvert class in the Json.NET library.

Answer 1

You won’t be able to use the JsonConvert class directly, as it expects all properties to have a name/mapping, and isn’t able to ascertain it because you are essentially using a custom format.

What you need to do is create a class that has the columns and the data and serialize into that, like so:

class CustomData
{
    public string Columns { get; set; }
    public object[,] Data { get; set; }
}

JsonConvert should be able to convert your data into this structure in .NET.

From there, it becomes more of a .NET issue, in that you have to get the names of the columns and data. You should be able to use LINQ to help with pairing the two and then use reflection to populate your item:

// The custom data structure, deserialized from JSON.
CustomData data = ...;

// The type of Employee.
Type type = typeof(Employee);

// Create a map of the property info to the ordinal in the
// Columns.
IDictionary<int, PropertyInfo> propertyMap = data.Columns.
    Select((p, i) => 
        new { Index = i, PropertyInfo = type.GetProperty(p) }).
    ToDictionary(p => p.Index, p => p.PropertyInfo);

// Cycle through the rows in the data.
var query =
    // Cycle through all of the rows.
    from row in Enumerable.Range(0, data.Data.GetLength(0))

    // Create the instance.
    let instance = new Employee()

    // For each column in the row.
    from column in Enumerable.Range(0, data.Data.GetLength(1))

    // Lookup the property info.
    let propertyInfo = propertyMap[column]

    // Select the instance, the property, and the value.
    select { 
        // This is used for grouping purposes, since
        // you can't guarantee that the type you are serializing
        // to will have natural identity properties and
        // you know the row corresponds to one singular instance.
        Row = row,
        Instance = instance, 
        PropertyInfo = propertyInfo,
        Value = data.Data[row, column]
    };

// Iterate through the items, setting the instance values.
foreach (var propertyAndData in query)
{
    // Set the property value on the instance.
    propertyAndData.PropertyInfo.
        SetValue(propertyAndData.Instance, Value, null);
}

// Group by the row and get the first item in each sequence.
IEnumerable<Employee> employees =
    from item in query
    groupby item by item.Row into g
    select g.First();

The only caveat for the above; if you are using a value type, then you will not populate the same instance as you iterate through this. In order to handle value types, you have to unwind the LINQ query and iterate through each row and column using for loops, creating the new instance on each new row and then using Reflection as above to populate the properties.