LINQ - Viết một phương thức mở rộng để lấy hàng có giá trị lớn nhất cho mỗi nhóm

Question

Ứng dụng của tôi thường cần nhóm một nhóm, sau đó trả về hàng có giá trị lớn nhất cho nhóm đó. Điều này khá dễ thực hiện trong LINQ:

myTable.GroupBy(r => r.FieldToGroupBy) 
.Select(r => r.Max(s => s.FieldToMaximize)) 
.Join(
    myTable, 
    r => r, 
    r => r.FieldToMaximize, 
    (o, i) => i) 

Bây giờ giả sử tôi muốn tóm tắt điều này theo cách riêng của nó. Tôi đã cố gắng viết này:

public static IQueryable<TSource> 
SelectMax<TSource, TGroupKey, TMaxKey>(
    this IQueryable<TSource> source, 
    Expression<Func<TSource, TGroupKey>> groupKeySelector, 
    Expression<Func<TSource, TMaxKey>> maxKeySelector) 
    where TMaxKey : IComparable 
{ 
    return source 
     .GroupBy(groupKeySelector) 
     .Join(
      source, 
      g => g.Max(maxKeySelector), 
      r => maxKeySelector(r), 
       (o, i) => i); 
} 

Thật không may điều này không biên dịch: maxKeySelector là một biểu thức (vì vậy bạn không thể gọi nó về r, và bạn thậm chí không thể vượt qua nó để Max Vì vậy, tôi cố gắng viết lại,. làm maxKeySelector một chức năng chứ không phải là một biểu thức:.

public static IQueryable<TSource> 
SelectMax<TSource, TGroupKey, TMaxKey>(
    this IQueryable<TSource> source, 
    Expression<Func<TSource, TGroupKey>> groupKeySelector, 
    Func<TSource, TMaxKey> maxKeySelector) 
    where TMaxKey : IComparable 
{ 
    return source 
     .GroupBy(groupKeySelector) 
     .Join(
      source, 
      g => g.Max(maxKeySelector), 
      r => maxKeySelector(r), 
       (o, i) => i); 
} 

Bây giờ này biên soạn Nhưng nó không thành công trong thời gian chạy: "tình trạng quá tải không được hỗ trợ sử dụng cho các nhà khai thác truy vấn 'Max'" Đây là những gì tôi đang mắc kẹt trên: tôi cần phải tìm đúng cách để chuyển maxKeySelector vào Max().

Bất kỳ đề xuất nào? Tôi là chúng tôi ing LINQ to SQL, mà dường như tạo sự khác biệt.

Answer 1

Trước hết, tôi muốn chỉ ra rằng những gì bạn đang cố gắng làm là thậm chí dễ dàng hơn bạn nghĩ trong LINQ:

myTable.GroupBy(r => r.FieldToGroupBy) 
    .Select(g => g.OrderByDescending(r => r.FieldToMaximize).FirstOrDefault()) 

... mà nên làm cho cuộc sống của chúng ta một chút dễ dàng hơn cho phần thứ hai:

public static IQueryable<TSource> 
SelectMax<TSource, TGroupKey, TMaxKey>(
    this IQueryable<TSource> source, 
    Expression<Func<TSource, TGroupKey>> groupKeySelector, 
    Expression<Func<TSource, TMaxKey>> maxKeySelector) 
    where TMaxKey : IComparable 
{ 
    return source 
     .GroupBy(groupKeySelector) 
     .Select(g => g.AsQueryable().OrderBy(maxKeySelector).FirstOrDefault()); 
} 

Điều quan trọng là bằng cách làm cho nhóm của bạn một IQueryable, bạn mở một tập hợp mới các phương pháp LINQ có thể mất biểu thức thực tế chứ không phải là tham Func s. Điều này phải tương thích với hầu hết các nhà cung cấp LINQ tiêu chuẩn.

Answer 2

Rất thú vị. Đôi khi "động" có thể khiến bạn mất nhiều thời gian hơn trong việc phát triển tuyệt đối và thực thi thời gian chạy hơn là giá trị (IMHO). Tuy nhiên, đây là đơn giản nhất:

public static IQueryable<Item> _GroupMaxs(this IQueryable<Item> list) 
{ 
    return list.GroupBy(x => x.Family) 
     .Select(g => g.OrderByDescending(x => x.Value).First()); 
} 

Và, đây là cách tiếp cận năng động nhất:

public static IQueryable<T> _GroupMaxs<T, TGroupCol, TValueCol> 
    (this IQueryable<T> list, string groupColName, string valueColName) 
{ 
    // (x => x.groupColName) 
    var _GroupByPropInfo = typeof(T).GetProperty(groupColName); 
    var _GroupByParameter = Expression.Parameter(typeof(T), "x"); 
    var _GroupByProperty = Expression 
      .Property(_GroupByParameter, _GroupByPropInfo); 
    var _GroupByLambda = Expression.Lambda<Func<T, TGroupCol>> 
     (_GroupByProperty, new ParameterExpression[] { _GroupByParameter }); 

    // (x => x.valueColName) 
    var _SelectParameter = Expression.Parameter(typeof(T), "x"); 
    var _SelectProperty = Expression 
      .Property(_SelectParameter, valueColName); 
    var _SelectLambda = Expression.Lambda<Func<T, TValueCol>> 
     (_SelectProperty, new ParameterExpression[] { _SelectParameter }); 

    // return list.GroupBy(x => x.groupColName) 
    // .Select(g => g.OrderByDescending(x => x.valueColName).First()); 
    return list.GroupBy(_GroupByLambda) 
     .Select(g => g.OrderByDescending(_SelectLambda.Compile()).First()); 
} 

Như bạn thấy, tôi đi trước Mở rộng phương pháp của tôi với dấu gạch dưới. Bạn không cần phải làm điều này, tất nhiên. Chỉ cần lấy ý tưởng chung và chạy với nó.

Bạn sẽ gọi nó là như thế này:

public class Item 
{ 
    public string Family { get; set; } 
    public int Value { get; set; } 
} 

foreach (Item item in _List 
     .AsQueryable()._GroupMaxs<Item, String, int>("Family", "Value")) 
    Console.WriteLine("{0}:{1}", item.Family, item.Value); 

Best of luck!