如何反序列化具有变量名和数组的 JSON

Question

All, I think I am close with this but I am failing to find the exact class structure that works, please note I can't use JSON.net (sorry I think this is now referred to as newtonsoft json) this needs to be in core .net4.5

I have a JSON which is similar to this:

{"code":"ab", "notificationMessages": {
            "A": [
                {
                    "code": 3010,
                    "message": "The field is required."
                }
            ],
            "B": [
                {
                    "code": 3010,
                    "message": "The field  must be a string or array type with a maximum length of '1'."
                }
            ],
            "C": [
                {
                    "code": 3020,
                    "message": "The  field is required."
                }
            ]
        }
    }

However the messages AB and C could be anything. Therefore as I understand it the notificationMessages is a list of dictionaries? However, I don't quite seem to be able to find the syntax that works. I'm sure it's something dumb I am missing. This is what I currently have

public class Root
    {
        public string code { get; set; }
        public Notificationmessages notificationMessages { get; set; }
    }

    public class Notificationmessages
    {
        public List<Dictionary<string, MessageArray>> message { get; set; }

    }

    public class MessageArray
    {
        public int code { get; set; }
        public string message { get; set; }

    }

But however, I try and deserialise it and access messages I get an object that is not set...

I have created a fiddle but can't seem to add Script. Serialization I assume as it has been replaced with the latest nuGet but I am restricted to 4.5

https://dotnetfiddle.net/RjCSim

Edit: Adding answer as provided below

For my specific scenario this worked:

  public class RootObj
    {
       
    public string Code { get; set; }
  
    public Dictionary<string, List<NotificationMessage>> NotificationMessages { get; set; }
}
public class NotificationMessage
{       
    public string Code { get; set; }       
    public string Message { get; set; }
}

Accessed like:

            var result = new JavaScriptSerializer().Deserialize<RootObj>(simpleJson);
        foreach (KeyValuePair<string, List<NotificationMessage>> messages in result.NotificationMessages)
        {

            foreach (NotificationMessage message in messages.Value) {
                Console.WriteLine(message.Message);
            
            }
        }

Answer 1

You have it mostly sorted but few things to change to make it work.

{ } is always an object and [ ] is always a list / array. You are trying to deserialize an object to an array which is whats failing. Following works,

public class RootObj
{
    [JsonProperty("code")]
    public string Code { get; set; }
    [JsonProperty("notificationMessages")]
    public Dictionary<string, List<NotificationMessage>> NotificationMessages { get; set; }
}
public class NotificationMessage
{
    [JsonProperty("code")]
    public string Code { get; set; }
    [JsonProperty("message")]
    public string Message { get; set; }
}

and you can deserialize based on this command using Newtonsoft.Json .

var obj = JsonConvert.DeserializeObject<RootObj>(text);

In your question, notificationMessages is an object (Dictionary of string and Array of Objects).. which is why you have to define it as Dictionary. The other thing you will notice is the JsonProperty attribute. C# code standards dictate the first letter of the properties be capital so to work with the json, you have to add the attributes to properly deserialize.

Answer 2

If you create a class hierarchy that looks like this (you'll need better class names):

public class MessageAndCode
{
    public int code { get; set; }
    public string message { get; set; }
}

public class ABC
{
    public List<MessageAndCode> A { get; set; }
    public List<MessageAndCode> B { get; set; }
    public List<MessageAndCode> C { get; set; }
}

public class Outer
{
    public string code { get; set; }
    public ABC notificationMessages { get; set; }
}

and I use the NewtonSoft serializer like this:

public static void Test()
{
    var data = new Outer
    {
        code = "ab",
        notificationMessages = new ABC
        {
            A = new List<MessageAndCode>
            {
                new MessageAndCode
                {
                    code = 3010,
                    message = "Message A"
                }
            },
            B = new List<MessageAndCode>
            {
                new MessageAndCode
                {
                    code = 3015,
                    message = "Message B"
                }
            },
            C = new List<MessageAndCode>
            {
                new MessageAndCode
                {
                    code = 3020,
                    message = "Message C"
                }
            }
        }
    };

    var result = JsonConvert.SerializeObject(data);
}

I get this as output (after formatting):

{
  "code": "ab",
  "notificationMessages": {
    "A": [
      {
        "code": 3010,
        "message": "Message A"
      }
    ],
    "B": [
      {
        "code": 3015,
        "message": "Message B"
      }
    ],
    "C": [
      {
        "code": 3020,
        "message": "Message C"
      }
    ]
  }
}

Which I believe matches what you want. I understand you want to use a different serializer, but this should work with any serializer.

Note that my class definitions are very different from yours, but mine match what your desired JSON looks like

====

UPDATE

Since you want the "ABC to be variable", change the Outer class to look like:

public class Outer2
{
    public string code { get; set; }
    public Dictionary<string, List<MessageAndCode>> notificationMessages { get; set; }
}

Now, the initialization looks like:

var data2 = new Outer2
{
    code = "ab",
    notificationMessages = new Dictionary<string, List<MessageAndCode>>
    {
        {
            "A", new List<MessageAndCode>
            {
                new MessageAndCode
                {
                    code = 3010,
                    message = "Message A"
                },
            }
        },
        {
            "B", new List<MessageAndCode>
            {
                new MessageAndCode
                {
                    code = 3020,
                    message = "Message B"
                },
            }
        },
        {
            "C", new List<MessageAndCode>
            {
                new MessageAndCode
                {
                    code = 3030,
                    message = "Message C"
                },
            }
        },
        {
            "Bonus", new List<MessageAndCode>
            {
                new MessageAndCode
                {
                    code = 3040,
                    message = "Message Bonus"
                },
            }
        },
    }
};

The serialized output now looks like:

{
  "code": "ab",
  "notificationMessages": {
    "A": [
      {
        "code": 3010,
        "message": "Message A"
      }
    ],
    "B": [
      {
        "code": 3020,
        "message": "Message B"
      }
    ],
    "C": [
      {
        "code": 3030,
        "message": "Message C"
      }
    ],
    "Bonus": [
      {
        "code": 3040,
        "message": "Message Bonus"
      }
    ]
  }
}

Once again, the different serializer shouldn't make a difference (I don't work in Core, so you are getting what I can get for you). Serializers should work round-trip , so you should be able to deserialize this into the the class structure I have provided.

To prove my point, this code works:

var result = JsonConvert.SerializeObject(data2);
var deserialize = JsonConvert.DeserializeObject<Outer2>(result);