23

具有自定义排序比较器的任何给定 Linq 表达式有两种格式：

格式 1

var query =
    source
    .Select(x => new { x.someProperty, x.otherProperty } )
    .OrderBy(x => x, new myComparer());

格式 2

var query =
    from x in source
    orderby x // comparer expression goes here?
    select new { x.someProperty, x.otherProperty };

问题：
第二种格式的order-by表达式的语法是什么？

不是问题：
如何使用第一种格式所示的自定义比较器。

奖励积分：
上面列出的两种 Linq 格式是否有实际的正式名称？

4

4 回答 4

22

第二种格式的 order-by 表达式的语法是什么？

它不存在。来自orderby 子句文档：

您还可以指定自定义比较器。但是，它只能通过使用基于方法的语法来使用。

如何以第一种格式使用自定义比较器。

你写对了。你可以通过IComparer<T>你写的。

上面列出的两种 Linq 格式是否有实际的正式名称？

格式 1 称为“基于方法的语法”（来自上一个链接），格式 2 是“查询表达式语法”（来自此处）。

于 2012-10-05T20:47:34.090 回答
2

如何使用自定义比较器，如第一种格式所示。

您不能使用该格式的自定义比较器。

上面列出的两种 Linq 格式是否有实际的正式名称？

格式1是方法语法，格式2是“查询语法”，

于 2012-10-05T20:46:43.403 回答
2

问题：

这在查询语法中是不可能的，因为没有重载。

不是问题：

只有使用反射来比较对象时，才能使用具有匿名类型的比较器，最好使用类型化实现进行比较。

如果您不想创建类型化实现，可以使用Tuple：

var query =
    source
    .Select(x => new Tuple<string, int>(x.someProperty, x.otherProperty))
    .OrderBy(x => x, new MyComparer());

public class MyComparer : IComparer<Tuple<string, int>>
{
  public int Compare(Tuple<string, int> x, Tuple<string, int> y)
  {
    return x.Item1.CompareTo(y.Item1);
  }
}

赠金：

  • 查询语法或理解语法
  • 方法语法或扩展方法语法
于 2012-10-05T20:52:39.197 回答
2

这不一定回答原始问题，但它在一定程度上扩展了概述的一些可能性。我发布这个以防其他人遇到类似的问题。此处发布的解决方案概述了在其他情况下可能有用的通用顺序选项。在此示例中，我想按不同的属性对文件列表进行排序。

/// <summary>
/// Used to create custom comparers on the fly
/// </summary>
/// <typeparam name="T"></typeparam>
public class GenericCompare<T> : IComparer<T>
{
    // Function use to perform the compare
    private Func<T, T, int> ComparerFunction { set; get; }

    // Constructor
    public GenericCompare(Func<T, T, int> comparerFunction)
    {
        ComparerFunction = comparerFunction;
    }

    // Execute the compare
    public int Compare(T x, T y)
    {

        if (x == null || y == null) 
        {
            // These 3 are bell and whistles to handle cases where one of the two is null, to sort to top or bottom respectivly
            if (y == null && x == null) { return 0; }
            if (y == null) { return 1; }
            if (x == null) { return -1; }
        }

        try
        {
            // Do the actual compare
            return ComparerFunction(x, y);
        }
        catch (Exception ex)
        {
            // But muffle any errors
            System.Diagnostics.Debug.WriteLine(ex);
        }

        // Oh crud, we shouldn't be here, but just in case we got an exception.
        return 0;
    }
}

然后在实现中……</p> 

        GenericCompare<FileInfo> DefaultComparer;

        if (SortOrder == SORT_FOLDER_FILE)
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr1.FullName.ToLower().CompareTo(fr2.FullName.ToLower());
            });
        }
        else if (SortOrder == SORT_SIZE_ASC)
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr1.Length.CompareTo(fr2.Length);
            });
        }
        else if (SortOrder == SORT_SIZE_DESC)
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr2.Length.CompareTo(fr1.Length);
            });
        }
        else
        {
            DefaultComparer = new GenericCompare<FileInfo>((fr1, fr2) =>
            {
                return fr1.Name.ToLower().CompareTo(fr2.Name.ToLower());
            });
        }

        var ordered_results = (new DirectoryInfo(@"C:\Temp"))
                .GetFiles()
                .OrderBy(fi => fi, DefaultComparer);

最大的优点是您不需要为每个订单创建一个新类，您只需连接一个新的 lambda。显然，这可以通过各种方式进行扩展，所以希望它会在某个时间、某个地方对某人有所帮助。

于 2013-09-01T05:32:44.067 回答