C# 我可以在Linq查询中选择多个对象吗

我可以在select中返回多个项目吗？例如，我有一个固定装置的列表（想想足球（或美国佬的足球）固定装置）。每场比赛包括主客场球队和主客场比分。我想让所有打成平局的球队都上场。我想用像这样的东西

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

IEnumerable drew=来自装置中的装置
其中fixture.Played&（fixture.HomeScore==fixture.AwayScore）
选择fixture.HomeTeam&&fixture.AwayTeam；

我知道这个语法不正确，但我不知道是否可以这样做。我需要两个查询，然后连接它们吗

编辑：这确实是一件学习的事情，所以以任何特定的方式实现这一点都不重要。基本上，在这一阶段，我想要的是一份已经抽签的球队名单。例如，对于给定的固定装置列表，我可以找到所有抽签的球队，这样我就可以将他们在表格中的排名更新1分（3分代表胜利，0分代表失败）。，即选择-匿名类型1

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

---

编辑：抱歉，误解了您原来的问题，请重新编写答案

您可以使用“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);

IEnumerable=
（从夹具中的夹具）
其中fixture.Played&（fixture.HomeScore==fixture.AwayScore）
选择新列表（）
{HomeTeam=fixture.HomeTeam，
AwayTeam=fixture.AwayTeam
}).SelectMany（团队=>team）；

---

这将返回绘制的团队的扁平列表。

或者您可以定义一个类型来保存所有数据：

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; }
}

IEnumerable drew=来自装置中的装置
其中fixture.Played&（fixture.HomeScore==fixture.AwayScore）
选择新建团队群集{
Team1=fixture.HomeTeam，
团队2=fixture.AwayTeam，
分数1=fixture.HomeScore，
分数2=fixture.AwayScore
};
类团队集群{
公共团队1{get；set；}
公共团队2{get；set；}
公共整数Score1{get；set；}
公共整数Score2{get；set；}
}

我认为您正在寻找以下联合方法：

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);

IEnumerable drew=（来自装置中的装置
我在哪里玩
&&（fixture.HomeScore==fixture.AwayScore）
选择fixture.HomeTeam）
.活接头（从夹具中的夹具）
我在哪里玩
&&（fixture.HomeScore==fixture.AwayScore）
选择fixture.AwayTeam）；

以下内容将返回IEnumerable：

其他办法 迭代器块 迭代器块也可以实现同样的效果，但我怀疑这很少是最好的方法：

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;
    }
}

根据装置的来源/实现方式，可能值得考虑“缓存”绘制的装置，以避免必须枚举装置两次

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=
（从夹具中的夹具）
其中fixture.Played&（fixture.HomeScore==fixture.AwayScore）
选择夹具
).ToList（）；
数字绘图=
（从绘制中选择draw.HomeTeam）
.Union（从引入图中选择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));

var-draws=
固定设施
.Where（fxtr=>fxtr.Played&（fxtr.HomeScore==fxtr.AwayScore））
.ToList（）；
数字绘图=
draws.Select（fixture=>fixture.HomeTeam）
.Union（draws.Select（fixture=>fixture.AwayTeam））；

修改Fixture类

可以考虑在夹具类中加入“参与小组”以获得：

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

IEnumerable=
从夹具中的夹具
其中fixture.Played&（fixture.HomeScore==fixture.AwayScore）
来自fixture.ParticipatingTeam中的团队
选择团队；

但正如@MattDeKrey指出的，这需要合同变更

代码示例

---

代码示例可以在

上找到。我自己尝试了一下，得出了与“视情况而定”相同的版本

使用查询理解语法：

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=
fixtures.Where（f=>f.Played&f.HomeScore==f.AwayScore）
.SelectMany（f=>new[]{f.HomeTeam，f.AwayTeam}）
.Distinct（）；

我遇到了这个问题，找不到我想要的东西，所以我写了一个小的扩展方法，实现了我想要的

public static IEnumerable<R> MapCombine<M, R>(this IEnumerable<M> origList, params Func<M, R>[] maps)
{
    foreach (var item in origList)
    foreach (var map in maps)
    {
        yield return map(item);
    }
}

---

有趣的是，intellisense对此并不满意，在下拉列表的顶部没有lamdba表达式，但是在“=>”之后，它非常高兴。但最重要的是编译器很高兴。

这不是他想要的答案。他想要一个团队列表，而不是带有hometeam和awayteam属性的匿名类型列表。这是真的。。。我可以用匿名类型绕过它。。。我只是想知道是否有一种方法可以得到一份球队名单。如果这是唯一的方法，这是唯一的方法，我同意这不会返回一个团队列表，但我认为他最好修改他的代码以支持处理这种anon类型。如果James Hay可以更新他的问题来描述他的用法，这可能会有所帮助。我认为他的问题已经完美地描述了他的要求：“我想得到一份抽签团队的列表。”他可能不想在这里使用匿名类型的原因很多（需要在这个方法之外传递列表是很常见的）.自最初发布以来，元组已添加到.Net/C#中，在许多可以使用匿名类型的地方，元组可能是一个选项+1对于您的第一个查询-不需要更改合同，并且比主要答案更有效。最后一个示例适用于我。还教我可以使用类型推断来声明数组。每天都是学校的一天。有任何LINQ关键字等同于

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));

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

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});

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();

public static IEnumerable<R> MapCombine<M, R>(this IEnumerable<M> origList, params Func<M, R>[] maps)
{
    foreach (var item in origList)
    foreach (var map in maps)
    {
        yield return map(item);
    }
}

var drew = fixtures.Where(fixture => fixture.Played && 
                        (fixture.HomeScore == fixture.AwayScore))
                    .MapCombine(f => f.HomeTeam, f => f.AwayTeam);