public void IntersectBy_Uses_The_Specified_Key_Comparer()
{
var source = new[]
{
new Foo(0, 1),
new Foo(0, 2),
new Foo(1, 3),
new Foo(-2, 5),
new Foo(-2, 0),
new Foo(3, 2)
}.ForbidMultipleEnumeration();
var other = new[]
{
new Foo(2, 5),
new Foo(-3, 2)
}.ForbidMultipleEnumeration();
var comparer = XEqualityComparer <int> .By(Math.Abs);
var result = source.IntersectBy(other, f => f.X, comparer);
result.Should().Equal(
new Foo(-2, 5),
new Foo(3, 2)
);
}
public void DistinctUntilChangedBy_Uses_Specified_Comparer()
{
var source = new[]
{
new Foo(0, 1),
new Foo(0, 2),
new Foo(-1, 3),
new Foo(1, 8),
new Foo(2, 5),
new Foo(0, 3),
new Foo(2, 0),
new Foo(-2, 2)
}.ForbidMultipleEnumeration();
var comparer = XEqualityComparer <int> .By(Math.Abs);
var result = source.DistinctUntilChangedBy(f => f.X, comparer);
result.Should().Equal(
new Foo(0, 1),
new Foo(-1, 3),
new Foo(2, 5),
new Foo(0, 3),
new Foo(2, 0)
);
}
public void GroupUntilChangedBy_Uses_Specified_Comparer()
{
var source = new[]
{
new Foo(0, 1),
new Foo(0, 2),
new Foo(-1, 3),
new Foo(1, 8),
new Foo(2, 5),
new Foo(0, 3),
new Foo(2, 0),
new Foo(-2, 2)
}.ForbidMultipleEnumeration();
var comparer = XEqualityComparer <int> .By(Math.Abs);
var result = source.GroupUntilChangedBy(f => f.X, comparer).ToArray();
result.Length.Should().Be(5);
result[0].Key.Should().Be(0);
result[0].Should().Equal(new Foo(0, 1), new Foo(0, 2));
result[1].Key.Should().Be(-1);
result[1].Should().Equal(new Foo(-1, 3), new Foo(1, 8));
result[2].Key.Should().Be(2);
result[2].Should().Equal(new Foo(2, 5));
result[3].Key.Should().Be(0);
result[3].Should().Equal(new Foo(0, 3));
result[4].Key.Should().Be(2);
result[4].Should().Equal(new Foo(2, 0), new Foo(-2, 2));
}
public void DistinctUntilChanged_Uses_Specified_Comparer()
{
var source = new[] { -1, 1, -1, 2, 3, -3, 1, 3, -2, 2 }.ForbidMultipleEnumeration();
var comparer = XEqualityComparer <int> .By(Math.Abs);
var result = source.DistinctUntilChanged(comparer);
result.Should().Equal(-1, 2, 3, 1, 3, -2);
}
public void ToHashSet_Uses_The_Provided_Comparer()
{
var items = new[] { 4, -8, 15, 16, -23, 42 };
var source = items.ForbidMultipleEnumeration();
var comparer = XEqualityComparer <int> .By(Math.Abs);
var hashSet = source.ToHashSet(comparer);
hashSet.Should().Equal(items, comparer.Equals);
}
public void CommonPrefix_Uses_The_Specified_Comparer()
{
var source = new[] { 4, 8, 15, 16, 23, 42 }.ForbidMultipleEnumeration();
var other = new[] { -4, 8, -15, -99, -123, 999 }.ForbidMultipleEnumeration();
var comparer = XEqualityComparer <int> .By(Math.Abs);
var result = source.CommonPrefix(other, comparer);
result.Should().Equal(4, 8, 15);
}
public void GroupUntilChanged_Uses_Specified_Comparer()
{
var source = new[] { -1, 1, -1, 2, 3, -3, 1, 3, -2, 2 }.ForbidMultipleEnumeration();
var comparer = XEqualityComparer<int>.By(Math.Abs);
var result = source.GroupUntilChanged(comparer).ToArray();
result.Length.Should().Be(6);
result[0].Key.Should().Be(-1);
result[0].Should().Equal(-1, 1, -1);
result[1].Key.Should().Be(2);
result[1].Should().Equal(2);
result[2].Key.Should().Be(3);
result[2].Should().Equal(3, -3);
result[3].Key.Should().Be(1);
result[3].Should().Equal(1);
result[4].Key.Should().Be(3);
result[4].Should().Equal(3);
result[5].Key.Should().Be(-2);
result[5].Should().Equal(-2, 2);
}
/// <summary>
/// 根据一个比较器返回非重复函数
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="source"></param>
/// <param name="keySelector">比较器</param>
/// <returns></returns>
public static IEnumerable <TSource> DistinctBy <TSource>(this IEnumerable <TSource> source,
Func <TSource, dynamic> keySelector)
{
return(source.Distinct(XEqualityComparer <TSource> .Get(keySelector)));
}
