LINQ查询以返回每个类别中价格最高的商品

Question

This is a follow up to a question I posted a short while ago. I got an answer, but I realized that I had simplified my example class to the point that I lost the original intent. Having already accepted an answer on the original question I thought it best to start another.

So, here's my new class:

public class Art
{
    public string Type { get; set; }
    public string Name { get; set; }
    public int Price { get; set; }
}

...and here's the list creation:

public static void Example0000()
{
    List<Art> art = new List<Art>();
    art.Add(new Art() { Price = 45, Type = "painting", Name = "Still Life in Maryland" });
    art.Add(new Art() { Price = 123, Type = "sculpture", Name = "Dying Sheep" });
    art.Add(new Art() { Price = 12, Type = "icon", Name = "Perplexed Smiley" });
    art.Add(new Art() { Price = 460, Type = "sculpture", Name = "Waves on Sand" });
    art.Add(new Art() { Price = 2030, Type = "painting", Name = "Robert in the Morning" });
    art.Add(new Art() { Price = 10, Type = "icon", Name = "Smiley Picking Nose" });
    art.Add(new Art() { Price = 700, Type = "painting", Name = "Birds in Autumn" });
    art.Add(new Art() { Price = 1400, Type = "sculpture", Name = "Holding Hands" });
    art.Add(new Art() { Price = 46, Type = "painting", Name = "Reeling Him In" });
    art.Add(new Art() { Price = 12000, Type = "sculpture", Name = "Old Dog" });
    art.Add(new Art() { Price = 6, Type = "icon", Name = "Hiding Smiley" });
    art.Add(new Art() { Price = 810, Type = "sculpture", Name = "Rhinestone Cowgirl" });
    art.Add(new Art() { Price = 250, Type = "painting", Name = "Upstairs, Downstairs" });
    art.Add(new Art() { Price = 3, Type = "icon", Name = "Dopey Smiley" });
    art.Add(new Art() { Price = 1000, Type = "painting", Name = "Young Love" });
    art.Add(new Art() { Price = 260, Type = "sculpture", Name = "Taking a Spill" });
}

What I want to get is a collection of objects, one for each Type, which have three properties; ArtType, ArtName and MostExpensivePrice. For each Type, I want the Name and Price for the highest priced item of that type.

So my list should look like:

painting______Robert_in_the_Morning______2030

sculpture_____Old Dog__________________12000

icon_________Perplexed Smiley______________12

What would the LINQ look like for that? The example that I am starting with looks like this:

var categories4 =
    from a in art
    group a by a.Type into g
    let maxPrice = g.Max(p => p.Price)
    select new { ArtType = g.Key, MostExpensive = g.Where(a => a.Price == maxPrice) };

Answer 1

Does this work for you?

var query =
    art
        .OrderByDescending(x => x.Price)
        .GroupBy(x => x.Type)
        .Select(x => x.First());

I get this result:

Answer 2

See the Enumerable.Aggregate() method.

The other answer given so far only returns the maximum price, which isn't what you're asking for here. If you use Enumerable.Aggregate() like this:

MostExpensive = g.Aggregate((art1, art2) => (art1.Price > art2.Price) ? art1 : art2)

Then your LINQ result will have instances of Art instead of just int, so you can display all of the information for the maximum instead of just the price.

EDIT:

In case it wasn't obvious from the above, the full expression can then be this:

var artprices =
    from a in art
    group a by a.Type into g
    let mostExpensive = g.Aggregate((art1, art2) => (art1.Price > art2.Price) ? art1 : art2)
    select new { ArtType = g.Key, ArtName = mostExpensive.Name, MostExpensivePrice = mostExpensive.Price };

And you'll have a result with elements having the three values you want.

EDIT 2:

And finally, being new to the site I can't add comments to the other answers, but I'll point out as objectively as I can that they are both deficient, in different ways.

One answer suggests evaluating the Max() method once for every element in the original collection, and then again for every Type value (ie each group). This is a classic O(N^2) scenario, which will perform fine for very small data sets but which will be abysmal for any non-trivial collection of data.

Two other answers suggest sorting the elements in each individual group. This is better, but still requires the memory and performance overhead of the sort. A typical sort is O(N log N), which is much better than O(N^2), but still not as good as the linear O(N) that using Aggregate() gets you. Again, no problem at all with small data sets, but a non-trivial collection will result in a noticeable performance decrease as compared to the more efficient approach.

Hope that helps!

Answer 3

Well, you got the first part right, you're just a little off with the second part. The first thing that you need to do is understand what GroupBy method returns. GroupBy essentially returns a list of lists (array of arrays or enumerable of enumerables).

Using a type declared as yours is:

public class Art
{
    public string Type { get; set; }
    public string Name { get; set; }
    public int Price { get; set; }
}

With this data:

List<Art> art = new List<Art>()
{
    new Art() { Price = 45, Type = "painting", Name = "Still Life in Maryland" }),
    new Art() { Price = 123, Type = "sculpture", Name = "Dying Sheep" }),
    new Art() { Price = 12, Type = "icon", Name = "Perplexed Smiley" }),
    new Art() { Price = 460, Type = "sculpture", Name = "Waves on Sand" });,
    new Art() { Price = 2030, Type = "painting", Name = "Robert in the Morning" }),
    new Art() { Price = 10, Type = "icon", Name = "Smiley Picking Nose" }),
    new Art() { Price = 700, Type = "painting", Name = "Birds in Autumn" }),
    new Art() { Price = 1400, Type = "sculpture", Name = "Holding Hands" }),
    new Art() { Price = 46, Type = "painting", Name = "Reeling Him In" }),
    new Art() { Price = 12000, Type = "sculpture", Name = "Old Dog" }),
    new Art() { Price = 6, Type = "icon", Name = "Hiding Smiley" }),
    new Art() { Price = 810, Type = "sculpture", Name = "Rhinestone Cowgirl" }),
    new Art() { Price = 250, Type = "painting", Name = "Upstairs, Downstairs" }),
    new Art() { Price = 3, Type = "icon", Name = "Dopey Smiley" }),
    new Art() { Price = 1000, Type = "painting", Name = "Young Love" }),
    new Art() { Price = 260, Type = "sculpture", Name = "Taking a Spill" })
}

Grouping a list of art objects results in something that looks like this:

IEnumerable<IGrouping<string, Art>> groupedByType = art.GroupBy(a => a.Type);

Where each IGrouping<string, Art> contains a list of Art where each piece in a list has the same Type . Taking this to the second step, we just need to select the maximum price from each group:

IEnumerable<Art> maxFromEachGroup = groupedByType
    // Take a single piece of art from each group
    .Select(group =>
        // Get the maximum piece of art by ordering from largest to smallest 
        // and taking the first
        group.OrderByDescending(a => a.Price).First() 
    );

Now you have a list of Art where the most expensive piece from each group is contained. The thing to be aware of with Max is that it returns the value of the maximum price compared to returning the piece of Art with the largest price. As such, the entire expression in LINQ expression form is:

var maxFromEachGroup = from a in art
                       group a by a.Type into g
                       select (from a in g orderby a.Price descending select a).First();

Answer 4

You are almost there. Remove the let as it's not needed and do a Max on the Price property:

var categories4 = from a in art
                  group a by a.Type into g
                  select new
                  {
                      ArtType = g.Key, 
                      MostExpensive = g.Max(a => a.Price)
                  };

The complicated part is getting the name of the art as it's not part of the grouping. First you need to decide what happens if 2 items of art with the same type have the same maximum price? Assuming you don't care, this will do the job:

var categories4 = from a in art
                  group a by a.Type into g
                  select new
                  {
                      ArtType = g.Key, 
                      Name = g.Where(a => a.Price == g.Max(b => b.Price))
                              .Select(a => a.Name).First(),
                      MostExpensive = g.Max(a => a.Price)
                  };