Как работать с вложенными массивами и объектами с помощью LINQ

Question

, поэтому я работаю над небольшим проектом, где я потребляю и десериализую строку json в объекты на C #. Я установил себе бизнес-логику, в которой я хочу найти команду и вернуть количество забитых голов (https://raw.githubusercontent.com/openfootball/football.json/master/2014-15/en.1.json)

Проблема в том, что я хочу вернуть количество голов, используя LINQ вместо цикла (мой оригинальный метод). Тем не менее, я не знаю, как я могу получить счет. * например 1004 *

namespace ConsoleApp
{
class Program
{

    private static string jsonUrl { get; set; } = "https://raw.githubusercontent.com/openfootball/football.json/master/2014-15/en.1.json";
    private static string teamKey { get; set; } = "swansea";
    static void Main()
    {
       var goal = Run(teamKey.ToLower());
       Console.WriteLine(goal);
       Console.ReadKey();
    }

    public static int Run(string team)
    {

        using (var webclient = new WebClient())
        {

            var rawJson = webclient.DownloadString(jsonUrl);

            var jsonModel = JsonConvert.DeserializeObject<RootObject>(rawJson);


            foreach (var rounds in jsonModel.rounds)
            {
                foreach (var match in rounds.matches)
                {
                    var goal = match.team1.key.Equals(teamKey) ? match.score1 : 0;

                    if (goal == 0)
                    {
                        goal = match.team2.key.Equals(teamKey) ? match.score2 : 0;
                    }
                    return goal;
                }
            }


            return 0;
        }

    }
}

public class Team1
{
    public string key { get; set; }
    public string name { get; set; }
    public string code { get; set; }
}

public class Team2
{
    public string key { get; set; }
    public string name { get; set; }
    public string code { get; set; }
}

public class Match
{
    public string date { get; set; }
    public Team1 team1 { get; set; }
    public Team2 team2 { get; set; }
    public int score1 { get; set; }
    public int score2 { get; set; }
}

public class Round
{
    public string name { get; set; }
    public List<Match> matches { get; set; }
}

public class RootObject
{
    public string name { get; set; }
    public List<Round> rounds { get; set; }
}

}

Приведенный выше код успешно выполняется и возвращает правильное количество голов в зависимости от футбольной команды. но я не думаю, что для производительности это лучший способ. (вход: "Суонси" ожидаемый результат: 2, фактический результат: 2)

массив представлен следующим образом:

"rounds": [
{
  "name": "Matchday 1",
"matches": [
    {
      "date": "2014-08-16",
      "team1": {
        "key": "manutd",
        "name": "Manchester United",
        "code": "MUN"
      },
      "team2": {
        "key": "swansea",
        "name": "Swansea",
        "code": "SWA"
      },
      "score1": 1,
      "score2": 2
    },
    {
      "date": "2014-08-16",
      "team1": {
        "key": "leicester",
        "name": "Leicester City",
        "code": "LEI"
      },
      "team2": {
        "key": "everton",
        "name": "Everton",
        "code": "EVE"
      },
      "score1": 3,
      "score2": 5
    }}]

Answer 1

Для получения удобочитаемого LINQ требуется синтаксис from x in y ... select z. Замените деталь, которая начинается с foreach (var rounds и заканчивается return 0; следующим кодом:

return (from round in jsonModel.rounds
from match in round.matches
let goal = match.team1.key.Equals(teamKey) ? match.score1 : 0
select goal == 0 ? (match.team2.key.Equals(teamKey) ? match.score2 : 0) : goal).FirstOrDefault();

Для ясности я сохранил это как код, указанный в вопросе. Было бы лучше извлечь вспомогательные методы, чтобы сделать LINQ более читабельным: один помощник для выражения match.team1.key.Equals(teamKey) ? match.score1 : 0 и один для выражения goal == 0 ? (match.team2.key.Equals(teamKey) ? match.score2 : 0) : goal.

from x in y ... select z можно превратить в цепочку методов LINQ. (Например, инструмент ReSharper может сделать это автоматически.) Но результат настолько ужасен, что нет смысла его показывать.