【问题标题】:How many Foos, and Boos ? (Linq, GroupBy) [closed]有多少 Foos 和 Boos ? (Linq,GroupBy)[关闭]
【发布时间】:2017-07-10 14:10:16
【问题描述】:

[编辑1] 我想使用 LINQ 获得“4 Foos,6 Boos”的结果。 [/编辑]

虽然对我来说这是初级的,但并不那么容易。

我写过这样的经典代码。它计算了所有 Foo 和 Boo 的计数。

var myList = new List<string[]>();
myList.Add(new string[] { "Foo", "1" });
myList.Add(new string[] { "Boo", "2" });
myList.Add(new string[] { "Foo", "3" });
myList.Add(new string[] { "Boo", "4" });
var myDictionary = new Dictionary<string, int>();
foreach (var x in myList)
    if (myDictionary.ContainsKey(x[0]))
        myDictionary[x[0]] += int.Parse(x[1]);
    else
        myDictionary.Add(x[0], int.Parse(x[1]));
MessageBox.Show(string.Join("\n", 
    myDictionary.Select(x => x.Key +" : "+ x.Value)));

所以,我有 4 个 Foos,6 个 Boos。

我学习失败了,Linq。像这样..

var myLinq = myList
    .OrderBy(x => x[0])
    .GroupBy(x => x[0])
    .Select(y => new
    {
        Key = y.Key,
        Value = y.Sum(x => x[1])
    });

请帮忙..

【问题讨论】:

  • 能否请您澄清一下您的问题有什么问题。
  • 您不能添加 字符串。您的 first sn-p 将它们解析为整数。对第二个做同样的事情
  • @BenderBending 实际上,我所有的 LinQ 都不合适。组“Key”只抓取“2”,因为它限制了 Foo(或 Boo)的存在。我想总结它的数量。谢谢评论
  • 退后一步,解释一下您希望样本输入的输出。
  • 1.在 group by 之前进行 order by 是没有意义的。订购是您最后要做的事情。

标签: c# linq group-by


【解决方案1】:
var myLinq = from m in myList
         group m by m[0] into g
         select new
         {
            Key = g.Key,
            Value = g.Sum(gg=>int.Parse(gg[1]))
         };

【讨论】:

  • 我可以有“点样式”吗?谢谢评论。
  • 您不能自己转换该代码吗?这并不难,你会从中学习。 @杰森
  • @James Curran 谢谢我已经确认过了。并尝试将其更改为点样式。
  • @PatrickHofman 是的。如果可以的话……
  • @PatrickHofman 不用担心。我已经为这些东西花了将近 3 个小时..
【解决方案2】:

如 cmets 中所述,您的第二个 sn-p 正在尝试将字符串 添加,就好像它们是数字一样。这会产生编译错误,因为您必须先将字符串解析为整数,然后才能添加它们。

以下代码使用int.Parse 将每个字符串解析为Sum() 函数内的整数:

var myList = new List<string[]>{
    new string[] { "Foo", "1" },
    new string[] { "Boo", "2" },
    new string[] { "Foo", "3" },
    new string[] { "Boo", "4" },
};

var myLinq = myList
    .OrderBy(x => x[0])
    .GroupBy(x => x[0])
    .Select(y => new
    {
        Key = y.Key,
        Value = y.Sum(x => int.Parse(x[1]))
    });

注意,这是一种非常不寻常的生成字符串和数字对的方法。它非常容易出错——如果你混淆了索引会发生什么?还是类型改变?

最好使用实际的类、元组或 ValueTuples,例如:

var myList = new List<(string,string)>{
    ("Foo", "1" ),
    ("Boo", "2" ),
    ("Foo", "3" ),
    ("Boo", "4" ),
};

var myLinq = myList
    .OrderBy(x => x.Item1)
    .GroupBy(x => x.Item1)
    .Select(y => new
    {
        Key = y.Key,
        Value = y.Sum(x => int.Parse(x.Item2))
    });

或者

var myList = new List<(string key,string value)>{
    ("Foo", "1" ),
    ("Boo", "2" ),
    ("Foo", "3" ),
    ("Boo", "4" ),
};

var myLinq = myList
    .GroupBy(x => x.key)
    .OrderBy(x => x.Key)
    .Select(y => new
    {
        Key = y.Key,
        Value = y.Sum(x => int.Parse(x.value))
    });

注意最后一个查询中GroupBy、OrderBy的顺序发生了变化。现在我可以看到每个字段的作用,我可以按组的键名排序组并获得:

Boo 6 
Foo 4 

【讨论】:

  • 请注意,.OrderBy(x =&gt; x[0]) 毫无意义。
  • @JamesCurran 一旦你给字段起正确的名字,你就会意识到 OP 想要通过组键排序
  • 也许(他不是很清楚这一点)。但无论如何,我认为 GroupBy 不一定会遵守项目的顺序,因此任何 OrderBy before GroupBy 都将被撤消。这就是我的观点。
  • @JamesCurran 我的观点是,对于索引,您没有意识到这一点。一旦你给出了名字,你就可以按照答案显示的顺序更正
  • 哇,我快到了。谢谢不错的答案。我已经确认了。
【解决方案3】:

为什么要创建字典?

var myList = new List<string[]>();
myList.Add(new string[] { "Foo", "1" });
myList.Add(new string[] { "Boo", "2" });
myList.Add(new string[] { "Foo", "3" });
myList.Add(new string[] { "Boo", "4" });

Console.WriteLine("Foo count: " + myList.Where(l => l[0] == "Foo").Count());
Console.WriteLine("Boo count: " + myList.Where(l => l[0] == "Boo").Count());

或者如果您只想创建一个字典并使用数字作为键

Dictionary<string, string> myDict = new Dictionary<string, string>();
myDict.Add("1", "Foo");
myDict.Add("2", "Boo");
myDict.Add("3", "Foo");
myDict.Add("4", "Boo");

Console.WriteLine("Foo count: " + myDict.Where(l => l.Value == "Foo").Count());
Console.WriteLine("Boo count: " + myDict.Where(l => l.Value == "Boo").Count());

【讨论】:

  • 什么字典?问题是关于没有字典的 LINQ 代码
  • @Ben 谢谢...您的第一个代码对我来说看起来不熟悉。我会研究它。 (第二个不适合我的情况。给出的数据......)
  • 不。第一个不是我的意图。
猜你喜欢
  • 1970-01-01
  • 2017-10-20
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2010-11-27
  • 1970-01-01
  • 2012-06-24
  • 1970-01-01
相关资源
最近更新 更多