如何在IEnumerable.GroupBy中产生一个匿名类 <T> 在C＃LINQ中“即时”（没有枚举结果）？

Question

I do like this now (thanks to StackOverflow):

IEnumerable<object> Get()
{
     var groups = _myDatas.GroupBy(
       data => new { Type = data.GetType(), Id = data.ClassId, Value = data.Value },
       (key, rows) => new 
       {
           ClassId = key.Id,
           TypeOfObject = key.Type,
           Value = key.Value,
           Count = rows.Count()
       }));

       foreach (var item in groups)
       {
           yield return item;
       }
}

IEnumerable<MyData> _myDatas;

But is possible to make faster or more "elegant" by not having last foreach loop, but yielding it when the group/anonymous class instance is created?

I would guess fastest way would be to write it open and:

1. sort the _myDatas
2. enumerate it and when group changes yield the last group

But I'm trying to learn some LINQ (and C# features in general) so I don't want to do that.

The rest of example is here:

public abstract class MyData
{
    public int ClassId;
    public string Value;
    //...
}

public class MyAction : MyData
{
    //...
}

public class MyObservation : MyData
{
    //...
}

Answer 1

You should be able to return groups directly, though you might need to change your return type from IEnumerable<Object> to just IEnumerable .

So:

IEnumerable Get()
{
    var groups = _myDatas.GroupBy(
        // Key selector
        data => new {
            Type = data.GetType(),
            Id = data.ClassId,
            Value = data.Value
        },
        // Element projector
        (key, rows) => new 
        {
           ClassId = key.Id,
           TypeOfObject = key.Type,
           Value = key.Value,
           Count = rows.Count()
        }
    );

    return groups;
}

groups has the type IEnumerable< IGrouping< TKey = Anonymous1, TElement = Anonymous2 > > , so you can return it directly.