Question

我一直试图在LINQ语句中使用OrderBy来处理匿名对象，但现在已经失败了。

我已经检查了这些：
Anonymous IComparer implementation
C# linq sort - quick way of instantiating IComparer
How to sort an array of object by a specific field in C#?

我花了几个小时尝试不同的方法，但必须有一些我不知道的东西。

假设有以下课程：

public class Product
{
   public int Id {get; set;}
   public string Name {get; set;}
   public int Popularity {get; set;}
   public decimal Price {get; set;}
}

products是这些对象的列表。

如何完成此LINQ语句，以便它可以与匿名对象一起使用？
要清楚，我知道我可以用不同的方式做到这一点，但我非常有兴趣学习如何使这个特定的例子有效。

var sortedProducts = products
                       .OrderBy(p => 
                              new {p.Popularity, p.Price}, 
                              [IComparer magic goes here]);

似乎应该可以实现ProjectionComparer：
http://code.google.com/p/edulinq/source/browse/src/Edulinq/ProjectionComparer.cs?r=0c583631b709679831c99df2646fc9adb781b2be

任何想法如何做到这一点？

更新：

我对此进行了快速的性能测试 - 匿名比较器解决方案vs标准orderby.thenby，似乎匿名解决方案相当慢，这可能是我们可能预期的。

         numProd  | Anon    | chained orderby clauses
         10 000   | 47 ms   | 31 ms
         100 000  | 468 ms  | 234 ms
         1 000 000| 5818 ms | 2387 ms
         5 000 000| 29547 ms| 12105 ms

Answer 1

您可以创建一个IComparer<T>实现，该实现使用您为比较提供的委托，并使用类型推断对其进行实例化（类似于“按示例执行”）：

static class AnonymousComparer
{
    public static IComparer<T> GetComparer<T>(T example, Comparison<T> comparison)
    {
        return new ComparerImpl<T>(comparison);
    }
    private class ComparerImpl<T> : IComparer<T>
    {
        private readonly Comparison<T> _comparison;
        public ComparerImpl(Comparison<T> comparison) { _comparison = comparison; }
        public int Compare(T x, T y) { return _comparison.Invoke(x, y); }
    }
}

然后使用它：

var comparer = AnonymousComparer.GetComparer(
    new { Popularity = 0, Price = 0m },
    (a, b) => //comparison logic goes here
    );

var sortedProducts = products
    .OrderBy(p =>
        new { p.Popularity, p.Price },
        comparer);

编辑：我刚查看了您链接到的投影比较器页面。使用该方法，您不需要类型推断的“example”参数。然而，仍然需要调整方法来采用代理而不是接口。这是：

//adapted from http://code.google.com/p/edulinq/source/browse/src/Edulinq/ProjectionComparer.cs?r=0c583631b709679831c99df2646fc9adb781b2be
static class AnonymousProjectionComparer
{
    private class ProjectionComparer<TElement, TKey> : IComparer<TElement>
    {
        private readonly Func<TElement, TKey> keySelector;
        private readonly Comparison<TKey> comparison;

        internal ProjectionComparer(Func<TElement, TKey> keySelector, Comparison<TKey> comparison)
        {
            this.keySelector = keySelector;
            this.comparison = comparison ?? Comparer<TKey>.Default.Compare;
        }

        public int Compare(TElement x, TElement y)
        {
            TKey keyX = keySelector(x);
            TKey keyY = keySelector(y);
            return comparison.Invoke(keyX, keyY);
        }
    }

    public static IComparer<TElement> GetComparer<TElement, TKey>(Func<TElement, TKey> keySelector, Comparison<TKey> comparison)
    {
        return new ProjectionComparer<TElement, TKey>(keySelector, comparison);
    }
}

Answer 2

你真的不需要一个匿名对象来通过普及降序然后定价来订购这些对象，你可以结合使用OrerBy和ThenBy，如：

var sortedProducts = products.OrderByDescending(p => p.Popularity)
    .ThenBy(p => p.Price);

要对匿名类型执行IComparer<T>，最好使用工厂从委托构造一个并使用类型推断（指定匿名类型而不推理是一件痛苦的事！）。

您可能希望仅仅为了排序来衡量创建匿名对象的性能影响，但Phoogs的答案提供了一种使用Comparison<T>委托动态构建IComparer<T>的好方法..

Answer 3

不完全是答案......但评论时间过长：很难创建合理的通用比较器。

虽然单个属性对象已经建立了良好的比较关系，但是对于多个甚至2个属性没有这样的东西。即当你试图在平面上订购点时，这是非常常见的问题：只有2个值（x，y），但没有办法说（x1，y1）＆lt; （x2，y2）所以每个人都同意它。

在大多数情况下，您最终会按属性1说明顺序，而不是通过属性2，......或通过将所有属性映射到单个值（即简单地将所有属性相乘）。这些方法很容易表达，而不需要LINQ中的通用比较器：

使用链接OrderBy（attr1）的属性排序.OrderBy（attr2）....
按度量排序OrderBy（attr1 * attr2）（或对象上的任何其他Metric）

LINQ OrderBy具有投影比较器的匿名对象

3 个答案: