Estoy usando c # y json.net 9.0.1

Tengo el siguiente json

    {
        "lineups": [
          {
            "55": {
              "id": "55",
              "game_id": "1",
              "player_id": "55",
              "jersey_number": "78"
            },
            "56": {
              "id": "56",
              "game_id": "1",
              "player_id": "56",
              "jersey_number": "77"
            },
            "57": {
              "id": "57",
              "game_id": "1",
              "player_id": "57",
              "jersey_number": "76"
            }
        }
     ]
 }

Todos los elementos de la matriz son de tipo Player. ¿Cómo puedo analizar el json para que cada elemento "55", "56", "57" se almacene en una lista de reproductores, lista?

El json de origen no se puede modificar ya que proviene de un tercero.

ACTUALIZAR Modificó el json para que sea válido,

0
Fetbi Irsat 23 ago. 2016 a las 22:54

2 respuestas

La mejor respuesta

Si creó dos clases como esta:

public class Lineup
{
    public List<Dictionary<string,Player>> lineups;
}

public class Player
{
    public string id {get; set; }
    public string game_id { get; set;}
    public string player_id {get;set;}
    public string jersey_number {get;set;}
}

Entonces debería (después de haber arreglado su JSON inválido), poder deserializar así:

var l = Newtonsoft.Json.JsonConvert.DeserializeObject<Lineup>(source);

Ejemplo: https://dotnetfiddle.net/e7eUUZ

También puede utilizar los distintos atributos de JSON.Net para personalizar la deserialización. Por ejemplo, es posible que desee utilizar JsonPropertyAttribute para asignar los nombres en su fuente JSON a los nombres de propiedad de C # que coinciden con el estándar.

2
Matt Burland 23 ago. 2016 a las 20:18

Dadas estas clases:

public class Lineup
{
    public List<Player> Players { get; set; }
}

public class Player
{
    public string id { get; set; }

    public string game_id { get; set; }

    public string player_id { get; set; }

    public string jersey_number { get; set; }
}

public class Result
{
    public List<Lineup> Lineups { get; set; }
}

Podría implementar un JsonConverter personalizado como este:

public class LineupConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Lineup);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;

        if (reader.TokenType != JsonToken.StartObject)
            throw new Exception("Expected an object");

        var jObject = (JObject)JObject.ReadFrom(reader);

        // I suspect the property name are the same as the id property
        // of the contained objects. Discarding the information from serialization
        var players = jObject.Properties()
            .Select(p => p.Value.ToObject<Player>());

        return new Lineup
        {
            Players = players.ToList()
        };

    }

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

Y luego usa:

var lineups = JsonConvert.DeserializeObject<Result>(json, new LineupConverter());

También puede anotar las propiedades Player con atributos JsonProperty y hacer que se parezcan más a C #.

1
Simon Belanger 23 ago. 2016 a las 20:21