标签: icomparer

我想弄清楚我需要实现哪些接口.它们基本上都做同样的事情.我何时会使用一个而不是另一个？

是否可以使用C#在方法调用中将lambda表达式作为IComparer参数传递？

例如

var x = someIEnumerable.OrderBy(aClass e => e.someProperty, 
(aClass x, aClass y) => 
  x.someProperty > y.SomeProperty ?  1 : x.someProperty < y.SomeProperty ?  -1 : 0);

我不能完全把它编译成所以我猜不是,但看起来lambda和匿名代表之间的这种明显的协同作用让我觉得我必须做一些愚蠢的错误.

TIA

我碰巧看到了一些代码,其中这个人将lambda表达式传递给ArrayList.Sort(这里是IComparer)或IEnumerable.SequenceEqual(IEnumerable列表,IEqualityComparer here),其中需要IComparer或IEqualityComparer.

我不能确定我是否看过它,或者我只是在做梦.我似乎无法在这些集合中找到任何接受Func <>或其方法签名中的委托的扩展.

有这样的过载/扩展方法吗？或者,如果没有,是否有可能像这样捣乱并传递一个算法(读委托),其中预期单方法接口？

更新 谢谢大家.那正是我所想.我一定是在做梦.我知道如何编写转换.我只是不确定我是否见过这样的东西,或者只是觉得我已经看过了.

又一次更新 看,在这里,我找到了一个这样的实例.毕竟我并没有做梦.看看这家伙在这做什么.是什么赋予了？

这是另一个更新: 好的,我明白了.那家伙正在使用Comparison<T>超载.尼斯.很好,但完全容易误导你.不过很好.谢谢.

IComparable和IComparerInterfaces有什么区别？是否有必要始终使用此Array.Sort()方法

我正在尝试使用a IComparer来对点列表进行排序.这是IComparer类:

public class CoordinatesBasedComparer : IComparer
{
    public int Compare(Object q, Object r)
    {
        Point a = (p)q;
        Point b = (p)r;
        if ((a.x == b.x) && (a.y == b.y))
            return 0;
        if ((a.x < b.x) || ((a.x == b.x) && (a.y < b.y)))
            return -1;

        return 1;
    }
}

在客户端代码中,我试图使用这个类来排序点p(类型List<Point>)的列表:

CoordinatesBasedComparer c = new CoordinatesBasedComparer();
Points.Sort(c);

代码出错了.显然它正在期待IComparer<Point>排序方法的论据.
我需要做些什么来解决这个问题？

我有一个通用的

List<MyClass>

where MyClass属性InvoiceNumber包含如下值:

200906/1
200906/2
..
200906/10
200906/11
200906/12

我的名单必然是一个

BindingList<T>

支持使用linq进行排序:

protected override void ApplySortCore(
           PropertyDescriptor property, ListSortDirection direction)
{

    _sortProperty = property;
    _sortDirection = direction;

    var items = this.Items;

    switch (direction)
    {
        case ListSortDirection.Ascending:
            items = items.OrderByDescending(x => property.GetValue(x)).ToList();
            break;
        case ListSortDirection.Descending:
            items = items.OrderByDescending(x => property.GetValue(x)).ToList();
            break;
    }

    this.Items = items;

}

但是默认的比较器排序(假设)如下:

200906/1
200906/10
200906/11
200906/12
200906/2

在这种情况下这是令人讨厌的.

现在我想用自己的方式IComparer<T>.它看起来像这样:

public class MyComparer : IComparer<Object>
{

    public int Compare(Object stringA, Object …

这个问题涉及基本相同代码的2种不同实现.

首先,使用委托创建一个比较方法,该方法可以在排序对象集合时用作参数:

class Foo
{
    public static Comparison<Foo> BarComparison = delegate(Foo foo1, Foo foo2)
    {
        return foo1.Bar.CompareTo(foo2.Bar);
    };
}

当我想要一种以与CompareTo函数提供的方式不同的方式对Foo对象的集合进行排序时,我使用上述方法.例如:

List<Foo> fooList = new List<Foo>();
fooList.Sort(BarComparison);

二,使用IComparer:

public class BarComparer : IComparer<Foo>
{
    public int Compare(Foo foo1, Foo foo2)
    {
        return foo1.Bar.CompareTo(foo2.Bar);
    }
}

当我想在Foo对象的集合中对Foo对象进行二进制搜索时,我使用上面的代码.例如:

BarComparer comparer = new BarComparer();
List<Foo> fooList = new List<Foo>();
Foo foo = new Foo();
int index = fooList.BinarySearch(foo, comparer);

我的问题是:

• 每种实现的优点和缺点是什么？
• 有哪些方法可以利用这些实现中的每一种？
• 有没有办法以这种方式组合这些实现,我不需要复制代码？
• 我是否可以仅使用其中一个实现来实现二分搜索和替代集合排序？

我使用lambda表达式来排序和搜索C#中的数组.我不想在我的类中实现IComparer接口,因为我需要对多个成员字段进行排序和搜索.

class Widget
{
    public int foo;

    public void Bar()
    {
        Widget[] widgets;

        Array.Sort(widgets, (a, b) => a.foo.CompareTo(b.foo));

        Widget x = new Widget();
        x.foo = 5;
        int index = Array.BinarySearch(widgets, x,
                                       (a, b) => a.foo.CompareTo(b.foo));
    }
}

虽然排序工作正常,但二进制搜索会产生编译错误无法将lambda表达式转换为类型'System.Collections.IComparer <Widget>',因为它不是委托类型.由于某种原因,Sort对IComparer和Comparison都有重载,但BinarySearch只支持IComparer.经过一些研究,我发现ComparisonComparer<T>将比较转换为IComparer 的笨重:

public class ComparisonComparer<T> : IComparer<T>
{
    private readonly Comparison<T> comparison;

    public ComparisonComparer(Comparison<T> comparison)
    {
        this.comparison = comparison;
    }

    int IComparer<T>.Compare(T x, T y)
    {
        return comparison(x, y);
    }
}

这允许二进制搜索如下工作:

int index = Array.BinarySearch(
  widgets,
  x, …

例如,我在c#中有一组字符串;

var example = new string[]{"c", "b", "a", "d"};

然后我对它进行排序,但是我的IComparer方法不起作用,并且通过似乎事物无限循环.

基本上我需要"b"先来,然后"c",然后我不关心任何其他人的顺序.

使用I Comparer<string>和Compare(string x, string y)方法可以吗？

编辑:代码

    public int Compare(string x, string y)
    {
        var sOrder = new string[] { "b", "c" };
        int index_x = -1;
        int index_y = -1;

        for (int i = 0; i < sOrder.Length;i++)
        {
            if (sOrder[i] == x)
                index_x = i;
            else if (sOrder[i] == y)
                index_y = i;
        }

        if (index_x >= 0 && index_y >= …

我想知道什么是更好用.

用于排序的IComparer类和Compare方法或列表上的LINQ orderby.两者都工作正常但哪一个更适合大型列表.