Я могу выбрать несколько объектов в запросе Linq

101 Образец LINQ , а именно, Выбор - Анонимные Типы 1

... select new { HomeTeam = fixture.HomeTeam, AwayTeam = fixture.AwayTeam };

Следующее возвратит IEnumerable< Team>:

IEnumerable<Team> drew =
    from fixture in fixtures
    where fixture.Played && (fixture.HomeScore == fixture.AwayScore)
    from team in new[]{fixture.HomeTeam, fixture.AwayTeam}
    select team;

Или, с быстрым стилем LINQ:

IEnumerable<Team> drew =
    fixtures
    .Where(fxtr => fxtr.Played && (fxtr.HomeScore == fxtr.AwayScore))
    .SelectMany(fixture => new[]{fixture.HomeTeam, fixture.AwayTeam});

Выравнивание и FlatMap

Это требование часто называют, 'сглаживаясь'. Таким образом, беря < Набор < Наборы Things> > и преобразование его к < Набор Things>.

SelectMany обе карты (приспособление к Массиву Команд) и сглаживается (последовательность Массивов Команды к последовательности Команд). Это подобно функции "flatMap" на других языках, таких как Java и JavaScript.

возможно разделить Отображение и Выравнивание:

IEnumerable<Team> drew =
    fixtures
    .Where(fxtr => fxtr.Played && (fxtr.HomeScore == fxtr.AwayScore))
    // map 
    .Select(fixture => new[]{fixture.HomeTeam, fixture.AwayTeam})
    // flatten
    .SelectMany(teams => teams);

Другие Подходы

Блок Итератора

то же может быть достигнуто с блоком итератора, но я подозреваю, что это редко - лучший подход:

IEnumerable<Team> Drew(IEnumerable<Fixture> fixtures){
    var draws = 
      fixtures
      .Where(fxtr => fxtr.Played && (fxtr.HomeScore == fxtr.AwayScore));

    foreach(var fixture in draws){
        yield return fixture.HomeTeam;
        yield return fixture.AwayTeam;
    }
}

Объединение

Объединение является также опцией, но имеет потенциал для создания различных результатов вышеупомянутого:

1. порядок результатов будет отличаться. Все Домашние результаты возвращаются затем, все Далеко заканчиваются.

2. Union перечисляет приспособления дважды, таким образом, в зависимости от того, как приспособления реализованы, существует потенциал для приспособлений, которые будут обновлены между вызовами. Например, если бы новое оттянутое приспособление было добавлено между вызовами затем Далеко, то команда могла бы быть возвращена, но не Хозяева поля.

, Поскольку Mike Powell описывает:

IEnumerable<Team> drew =
    ( from fixture in fixtures
      where fixture.Played && (fixture.HomeScore == fixture.AwayScore)
      select fixture.HomeTeam
    ).Union(
      from fixture in fixtures
      where fixture.Played  && (fixture.HomeScore == fixture.AwayScore)
      select fixture.AwayTeam );

В зависимости от того, как приспособления получены/реализованы, это может быть 'кэширование' достойное рассмотрения оттянутых приспособлений, чтобы избежать необходимости перечислять приспособления дважды.

var draws = 
    ( from fixture in fixtures
      where fixture.Played  && (fixture.HomeScore == fixture.AwayScore)
      select fixture
    ).ToList();

IEnumerable<Team> drew =
    (from draw in draws select draw.HomeTeam)
    .Union(from draw in draws select draw.AwayTeam);

Или использование быстрого стиля:

var draws = 
    fixtures
    .Where(fxtr => fxtr.Played && (fxtr.HomeScore == fxtr.AwayScore))
    .ToList();

IEnumerable<Team> drew =
    draws.Select(fixture => fixture.HomeTeam)
    .Union(draws.Select(fixture => fixture.AwayTeam));

Изменение класса

Приспособления можно было считать добавление "ParticipatingTeams" к классу Приспособления для получения:

IEnumerable<Team> drew =
    from fixture in fixtures
    where fixture.Played && (fixture.HomeScore == fixture.AwayScore)
    from team in fixture.ParticipatingTeams
    select team;

, но поскольку @MattDeKrey указывает, что это требует изменения контракта.

Примеры кода

Примеры кода доступны на [1 110] Repl.it

Пробование этого самостоятельно, я придумал ту же версию как 'это, зависит'.

Используя синтаксис понимания запроса:

IEnumerable<Team> drew =
    from fixture in fixtures
    where fixture.Played && (fixture.HomeScore == fixture.AwayScore)
    from team in new[]{fixture.AwayTeam, fixture.HomeTeam}
    select team;

Используя лямбду с дополнительными методами:

IEnumerable<Team> drew =
    fixtures.Where(f => f.Played && f.HomeScore == f.AwayScore)
    .SelectMany(f => new[]{f.HomeTeam, f.AwayTeam});

Редактирование: я не знаю возможно, ли команда, возможно играла и потянула несколько раз в Вашей базе данных, но если это возможно, затем Вы могли бы хотеть использовать Distinct оператор запроса:

IEnumerable<Team> drew =
    (from fixture in fixtures
     where fixture.Played && (fixture.HomeScore == fixture.AwayScore)
     from team in new[]{fixture.AwayTeam, fixture.HomeTeam}
     select team).Distinct();

или:

IEnumerable<Team> drew =
    fixtures.Where(f => f.Played && f.HomeScore == f.AwayScore)
    .SelectMany(f => new[]{f.HomeTeam, f.AwayTeam})
    .Distinct();

Или можно определить тип для содержания всех этих данных:

IEnumerable<TeamCluster> drew = from fixture in fixtures
                         where fixture.Played && (fixture.HomeScore == fixture.AwayScore)
                         select new TeamCluster {
                             Team1 = fixture.HomeTeam,
                             Team2 = fixture.AwayTeam,
                             Score1 = fixture.HomeScore,
                             Score2 = fixture.AwayScore
                         };

class TeamCluster {
    public Team Team1 { get; set; }
    public Team Team2 { get; set; }
    public int Score1 { get; set; }
    public int Score2 { get; set; }
}

Редактирование: Извините, неправильно понял Ваш исходный вопрос, поэтому переписал ответ.

Вы могли использовать оператор "SelectMany", чтобы сделать то, что Вы хотите:

IEnumerable<Team> drew =
           (from fixture in fixtures
            where fixture.Played && (fixture.HomeScore == fixture.AwayScore)
                  select new List<Team>()
                             { HomeTeam = fixture.HomeTeam,
                               AwayTeam = fixture.AwayTeam
                             }).SelectMany(team => team);

Это возвратит сглаженный список команд, которые потянули.