Json.NET: matrices de serialización/deserialización

Question

Estoy usando una biblioteca Json.NET. ¿Cuál es la forma más conveniente de serializar/deserializar matrices en JSON a través de C#? Por ejemplo, yo estoy tratando de deserializar el siguiente texto (al leer el archivo):

{ 
    "Name": "Christina", 
    "Gender": "female", 
    "Favorite_numbers": [11, 25 ,23] 
} 

estoy leyendo el texto anterior de un archivo a una variable:

JObject o = JObject.Parse(File.ReadAllText("input.txt")) 

Y luego, cuando me estoy tratando de extraer una matriz [11, 24, 23] con el

int[] num = (int[]) o["Favorite_numbers"] 

recibo un error.

¿Qué estoy haciendo mal? ¿Cómo leo correctamente una matriz? ¿Cómo leo correctamente las matrices de 2 dim del siguiente tipo [[1, 2, 3], [4, 5, 6]]?

Answer 1

La propiedad Favorite_numbers va a ser del tipo JArray ya que no hay forma de que infiera el tipo que debería ser. La forma más conveniente de deserializar ese objeto será definir una clase C# para él y usar el (los) método (s) JsonConvert.DeserializeObject<T>(...) para deserializar el JSON a su clase definida.

Answer 2

Depende de lo que esté haciendo. En su caso, la manera más fácil sería crear un JsonConverter. Por lo que podría hacer lo siguiente:

public class IntArrayConverter : JsonCreationConverter<int[]> 
{ 

    protected override int[] Create(Type objectType, JArray jArray) 
    { 
     List<int> tags = new List<int>(); 

     foreach (var id in jArray) 
     { 
      tags.Add(id.Value<int>()); 
     } 

     return tags.ToArray(); 
    } 
} 

public abstract class JsonCreationConverter<T> : JsonConverter 
{ 
    /// <summary> 
    /// Create an instance of objectType, based properties in the JSON Array 
    /// </summary> 
    /// <param name="objectType">type of object expected</param> 
    /// <param name="jObject">contents of JSON Array that will be deserialized</param> 
    /// <returns></returns> 
    protected abstract T Create(Type objectType, JArray jObject); 

    public override bool CanConvert(Type objectType) 
    { 
     return typeof(T).IsAssignableFrom(objectType); 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     JArray jArray = JArray.Load(reader); 

     T target = Create(objectType, jArray); 

     return target; 
    } 

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

A continuación, defina su modelo con el nuevo atributo:

public class Person 
{ 
    public string Name { get; set; } 
    public string Gender { get; set; } 
    [JsonConverter(typeof(IntArrayConverter))] 
    public int[] Favorite_numbers { get; set; } 
} 

y se puede utilizar como lo haría normalmente:

Person result = JsonConvert.DeserializeObject<Person>(@"{ 
       ""Name"": ""Christina"", 
       ""Gender"": ""female"", 
       ""Favorite_numbers"": [11, 25 ,23] 
      }");