牛顿JSON将复杂的密钥集合序列化为JSON

Question

I have the below dictionary, and I need to convert the complex key values into proper JSON.

static void Main(string[] args)
        {
            Dictionary<string, object> collectionProp = new Dictionary<string, object>();
            Dictionary<string, object> prop = new Dictionary<string, object>();
            prop.Add("content", "button");
            prop.Add("page.count", "10");
            prop.Add("columns.0.textAlign", "center");
            prop.Add("columns.1.textAlign", "left");
            var result = new Dictionary<string, object>();
            foreach (var pair in prop)
            {
                var key = pair.Key;                
                    var parts = key.Split('.');
                    var currentObj = result;
                    for (int i = 0; i < parts.Length - 1; i++)
                    {
                        var property = parts[i];
                        if (!currentObj.Keys.Contains(property))
                            currentObj[property] = new Dictionary<string, object>();
                        currentObj = (Dictionary<string, object>)currentObj[property];
                    }
                    currentObj[parts[parts.Length - 1]] = pair.Value;                
            }
            Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
            Console.ReadLine();
        }

And getting the following result.

{
  "content": "button",
  "page": {
    "count": "10"
  },
  "columns": {
    "0": {
      "textAlign": "center"
    },
    "1": {
      "textAlign": "left"
    }
  }
}

Expecting the columns should be grouped as JSON array. How to achieve this.?

The desired output:

{
  "content": "button",
  "page": {
    "count": "10"
  },
  "columns": [
    {
      "textAlign": "center"
    },
    {
      "textAlign": "left"
    }
  ]
}

Answer 1

JSON.NET will serialize dictionaries as JSON objects by default even though its keys are convertible to an integer. Instead of building a dictionary from the source you could build JObject hierarchy. These helper methods recognize array indices indices in your path to automatically build JArray container around them:

public static class JsonExtensions
{
    public static void SetValue(this JContainer container, string path, object value)
    {
        JToken token = container;
        var keys = path.Split('.');
        foreach (var key in keys)
        {
            int index;
            if (int.TryParse(key, out index))
            {
                var jArray = token as JArray;
                if (jArray == null)
                {
                    jArray = new JArray();
                    token.Replace(jArray);
                    token = jArray;
                }
                while (index >= jArray.Count)
                {
                    jArray.Add(JValue.CreateNull());
                }
                token = jArray[index];
            }
            else
            {
                var jObject = token as JObject;
                if (jObject == null)
                {
                    jObject = new JObject();
                    token.Replace(jObject);
                    token = jObject;
                }
                token = token[key] ?? (token[key] = JValue.CreateNull());
            }
        }
        token.Replace(new JValue(value));
    }

    public static void SetValues(this JContainer container, IEnumerable<KeyValuePair<string, object>> pairs)
    {
        foreach (var pair in pairs)
        {
            container.SetValue(pair.Key, pair.Value);
        }
    }
}

And here's how you get the results you expect:

var jObject = new JObject();
jObject.SetValues(new Dictionary<string, object>
{
    { "content", "button" },
    { "page.count", "10" },
    { "columns.0.textAlign", "center" },
    { "columns.1.textAlign", "left" }
});
Console.WriteLine(jObject.ToString(Formatting.Indented));

Note that the code sample I provided is no way near efficient and should be used just as an inspiration to achieve the result you require.

Also note that in some cases the order of values to build the JObject matters, but enumerating items from dictionary is non-deterministic . Therefore you might consider a better data structure for the source that guarantees order of key-value pairs in it such as an array.