JSON.NET Deserialization - Single Result vs Array

To handle this you have to use a custom JsonConverter. But you probably already had that in mind. You are just looking for a converter that you can use immediately. And this offers more than just a solution for the situation described. I give an example with the question asked.

How to use my converter:

Place a JsonConverter Attribute above the property. JsonConverter(typeof(SafeCollectionConverter))

public class Response
{
    [JsonProperty("ns1.model")]
    [JsonConverter(typeof(SafeCollectionConverter))]
    public List<Model> Model { get; set; }
}

public class Model
{
    [JsonProperty("@mh")]
    public string Mh { get; set; }

    [JsonProperty("ns1.attribute")]
    public ModelAttribute Attribute { get; set; }
}

public class ModelAttribute
{
    [JsonProperty("@id")]
    public string Id { get; set; }

    [JsonProperty("$")]
    public string Value { get; set; }
}

And this is my converter:

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;

namespace stackoverflow.question18994685
{
    public class SafeCollectionConverter : JsonConverter
    {
        public override bool CanConvert(Type objectType)
        {
            return true;
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            //This not works for Populate (on existingValue)
            return serializer.Deserialize<JToken>(reader).ToObjectCollectionSafe(objectType, serializer);
        }     

        public override bool CanWrite => false;

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            throw new NotImplementedException();
        }
    }
}

And this converter uses the following class:

using System;

namespace Newtonsoft.Json.Linq
{
    public static class SafeJsonConvertExtensions
    {
        public static object ToObjectCollectionSafe(this JToken jToken, Type objectType)
        {
            return ToObjectCollectionSafe(jToken, objectType, JsonSerializer.CreateDefault());
        }

        public static object ToObjectCollectionSafe(this JToken jToken, Type objectType, JsonSerializer jsonSerializer)
        {
            var expectArray = typeof(System.Collections.IEnumerable).IsAssignableFrom(objectType);

            if (jToken is JArray jArray)
            {
                if (!expectArray)
                {
                    //to object via singel
                    if (jArray.Count == 0)
                        return JValue.CreateNull().ToObject(objectType, jsonSerializer);

                    if (jArray.Count == 1)
                        return jArray.First.ToObject(objectType, jsonSerializer);
                }
            }
            else if (expectArray)
            {
                //to object via JArray
                return new JArray(jToken).ToObject(objectType, jsonSerializer);
            }

            return jToken.ToObject(objectType, jsonSerializer);
        }

        public static T ToObjectCollectionSafe<T>(this JToken jToken)
        {
            return (T)ToObjectCollectionSafe(jToken, typeof(T));
        }

        public static T ToObjectCollectionSafe<T>(this JToken jToken, JsonSerializer jsonSerializer)
        {
            return (T)ToObjectCollectionSafe(jToken, typeof(T), jsonSerializer);
        }
    }
}

What does it do exactly? If you place the converter attribute the converter will be used for this property. You can use it on a normal object if you expect a json array with 1 or no result. Or you use it on an IEnumerable where you expect a json object or json array. (Know that an array -object[]- is an IEnumerable) A disadvantage is that this converter can only be placed above a property because he thinks he can convert everything. And be warned. A string is also an IEnumerable.

And it offers more than an answer to the question: If you search for something by id you know that you will get an array back with one or no result. The ToObjectCollectionSafe<TResult>() method can handle that for you.

This is usable for Single Result vs Array using JSON.net and handle both a single item and an array for the same property and can convert an array to a single object.

I made this for REST requests on a server with a filter that returned one result in an array but wanted to get the result back as a single object in my code. And also for a OData result response with expanded result with one item in an array.

Have fun with it.

There is not an elegant solution to your problem in the current version of JSON.NET. You will have to write custom parsing code to handle that.

As @boyomarinov said you can develop a custom converter, but since your JSON is pretty simple you can just parse your JSON into an object and then handle the two cases like this:

var obj = JObject.Parse(json);

var responses = new Responses { Model = new List<Model>() };

foreach (var child in obj.Values())
{
    if (child is JArray)
    {
        responses.Model = child.ToObject<List<Model>>();
        break;
    }
    else
        responses.Model.Add(child.ToObject<Model>());

}

Use JRaw type proxy property ModelRaw:

public class Responses
{
    [JsonIgnore]
    public List<Model> Model { get; set; }

    [JsonProperty(PropertyName = "ns1.model")]
    public JRaw ModelRaw
    {
        get { return new JRaw(JsonConvert.SerializeObject(Model)); }
        set
        {
            var raw = value.ToString(Formatting.None);
            Model = raw.StartsWith("[")
                ? JsonConvert.DeserializeObject<List<Model>>(raw)
                : new List<Model> { JsonConvert.DeserializeObject<Model>(raw) };
        }
    }
}