标签: linq-group

我想用linq(对象列表)进行查询,我真的不知道怎么做,我可以做组和总和但不能选择其余的字段.例:

ID  Value     Name   Category
1   5         Name1  Category1  
1   7         Name1  Category1
2   1         Name2  Category2
3   6         Name3  Category3
3   2         Name3  Category3

我希望按ID分组,按值按SUM分组并返回所有这样的字段.

ID  Value     Name   Category
1   12        Name1  Category1  
2   1         Name2  Category2
3   8         Name3  Category3

我正在寻找LINQ等效于Sybase的LIST()或MySQL的group_concat()

它会转换:

User  Hobby
--------------
Bob   Football 
Bob   Golf 
Bob   Tennis 
Sue   Sleeping 
Sue   Drinking

至:

User  Hobby
--------------
Bob   Football, Golf, Tennis 
Sue   Sleeping, Drinking

我有一个项目列表:

public class Item
{
    public int ItemId { get; set; }
    public string ItemName { get; set; }
    public int ListId { get; set; }
}

1 Test1 1

2 Test2 1

3 Test3 1

4 List 2

5 List2 2

6 Testing 3

7 Testing2 3

8 Testing3 3

有没有办法让我分组ListId并将它们放入每个单独的桶中,​​即ListId1桶将包含所有物品ListId == 1.该列表是从SQL动态返回的,所以我不知道手头ListId会有多少.

我有一个非常简单的List<string>设置,每个项目包含许多单个字符(IE a foreach将控制到"a""k""p"等)

我想做的是能够对项目进行分组,并计算每个项目的数量,这样我得到的输出类似于:

a - 2
t - 3
y - 3

有关最佳方法的任何提示吗？

如果有任何帮助,我正在使用.Net 4.

我有两张桌子

TableA
aId
aValue

TableB
bId
aId
bValue

我想通过这两个表来加入这两个表aId,然后将它们分组bValue

var result = 
from a in db.TableA
join b in db.TableB on a.aId equals b.aId
group b by b.bValue into x
select new {x};

我的代码无法识别组后的联接.换句话说,分组工作,但连接不起作用(或者至少我无法弄清楚如何在连接后访问所有数据).

我想将我的LINQ查询分组ItemNumber并返回整个表的总数Quantity.

Example:
ItemNumber - ItemName - Quantity
100          Item1       1
150          Item2       2
100          Item1       2
200          Item3       1
150          Item2       2

Should be:
ItemNumber - ItemName - Quantity
100          Item1       3
150          Item2       4
200          Item3       1

这是我试图分组的查询:

public IQueryable<WebsiteOrderStatus> GetOrderStatusByAccountNumberWithoutDeleted
        (string accountNumber)
{
    return db.WebsiteOrderStatus
             .Where(x => x.AccountNumber == accountNumber && x.LastUpdatedStatus != 1);
}

到目前为止我的最好结果(虽然这不能编译):

public IQueryable<IGrouping<Int32?, WebsiteOrderStatus>> lol(string accountNumber)
{
     db.WebsiteOrderStatus
       .Where(x => x.AccountNumber == accountNumber && x.LastUpdatedStatus != 1)
       .GroupBy(g => …

我有以下方法。

public IEnumerable<Item> ChangeValueIEnumerable()
    {
        var items = new List<Item>(){
            new Item("Item1", 1),
            new Item("Item2", 1),
            new Item("Item3", 2),
            new Item("Item4", 2),
            new Item("Item5", 3)
        };

        var groupedItems = items.GroupBy(i => i.Value)
            .Select(x => new Item(x.First().Name, x.Key));

        foreach (var item in groupedItems)
        {
            item.CalculatedValue = item.Name + item.Value;
        }

        return groupedItems;
    }

在groupedItems集合中CalculatedValue，s 为空。但是，如果我在 s 具有值之后添加 a到句子ToList()中。例如：SelectGroupByCalculatedValue

 var groupedItems = items.GroupBy(i => i.Value)
            .Select(x => new Item(x.First().Name, x.Key)).ToList();

所以，问题是。为什么是这样？我想知道这样做的原因，对我来说解决方案是添加一个ToList()

更新：类的定义 …

我有一个名为两个交易表ParentTransaction和ChildTransaction其中TransactionId的ParentTransaction将作为外来ChildTransaction的TransactionId.

现在我想获得payamount未完成的ParentTransaction的所有TransactionId .

从下面的输出我想要事务Id 3的记录,因为只有1000支付了transactionid3而不是5000.

我有一个这样的表:

Transactionid(p.k)    PayAmount
  1                   1000
  2                   3000
  3                   5000
  4                   6000

ChildTransaction

Id        TransactionId(F.k)   DepositAmount
1           1                  600
2           1                  400
3           2                  1000
4           2                  1000
5           2                  1000
6           3                  2000

这是我的查询:

var data = (from tmp in context.ParentTransaction
            join tmp1 in context.ChildTransaction on tmp.Transactionid equals
            tmp1.Transactionid where tmp.PayAmount !=tmp1.DepositAmount
                    select tmp);

但在这里我得到了交易ID 1和2,尽管他们的交易已经完成了两个部分,即600和400的交易ID 1.

我有一个C#中的对象列表.所有对象都包含属性code1和code2(以及其他属性).

例:

List -> object = id, name, code1, code2, hours, amount.

有31个可能的code1值.有10个可能的code2值.

我需要将具有相同code1和code2值(唯一组合)的所有对象组合到它们自己的列表中,这些列表将保存在父列表中(以便以后可以迭代每个单独的列表.)

我有通过网络服务收到的数据HTTPWebRequest.在我使用NewtonSoft.Deserialize自定义类型(具有公共字符串属性的简单类)解析它之后,我想使用LINQ- 更具体地说,我想对数据进行分组来操纵这些数据.

我的问题是,如果我按单个字符串属性进行分组,则分组工作正常

from x in myList
group x by x.myStr into grp
select grp;

由于我想按更多列分组,我将返回一个自定义类型

new MyType { a = ..., b = ... }

然而,该小组没有工作.我认为原因必须是编译器不知道如何比较这些对象 - 所以如果这种类型实现IEqualityComparer<MyType>它将解决它.

但不,它仍然没有相应的分组,它创建了几个具有完全相同的字符串值的键.

我正在分组的自定义类型就像

public class MyType
{
    public string a;
    public string b;
    public string c;
}

我错过了什么想法？

这是上述场景的具体示例:

//The type that models the data returned from the web service
public class MyClass
{
    public string a { get; set; }

    public string b …