/// <summary>
/// Returns elements with a distinct key value by using the specified equality comparer to compare key values.
/// </summary>
/// <typeparam name="TSource">Source sequence element type.</typeparam>
/// <typeparam name="TKey">Key type.</typeparam>
/// <param name="source">Source sequence.</param>
/// <param name="keySelector">Key selector.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IEnumerable <TSource> Distinct <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <EqualityComparerBuilderFor <TKey>, IEqualityComparer <TKey> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TKey>());
return(source.Distinct(keySelector, comparer));
}
public void SubstitutesCompareDefaultForComparerDefault()
{
IEqualityComparer <Person> thenByComparer = EqualityComparerBuilder.For <Person>().EquateBy(p => p.FirstName);
var comparer = EqualityComparer <Person> .Default.ThenEquateBy(thenByComparer);
Assert.Equal(EqualityComparerBuilder.For <Person>().Default().ThenEquateBy(thenByComparer).ToString(), comparer.ToString());
}
/// <summary>
/// Creates a hash set from a sequence.
/// </summary>
/// <typeparam name="TSource">The type of the elements of the input sequence.</typeparam>
/// <param name="source">A sequence to create a hash set from.</param>
/// <param name="comparerFactory">The definition of a comparer to compare elements.</param>
public static HashSet <TSource> ToHashSet <TSource>(this IEnumerable <TSource> source, Func <EqualityComparerBuilderFor <TSource>, IEqualityComparer <TSource> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TSource>());
return(source.ToHashSet(comparer));
}
/// <summary>
/// Creates a lookup from an observable sequence according to a specified key selector function, and a comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
/// <typeparam name="TKey">The type of the lookup key computed for each element in the source sequence.</typeparam>
/// <param name="source">An observable sequence to create a lookup for.</param>
/// <param name="keySelector">A function to extract a key from each element.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IObservable <ILookup <TKey, TSource> > ToLookup <TSource, TKey>(this IObservable <TSource> source, Func <TSource, TKey> keySelector, Func <EqualityComparerBuilderFor <TKey>, IEqualityComparer <TKey> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TKey>());
return(source.ToLookup(keySelector, comparer));
}
/// <summary>
/// Returns consecutive distinct elements by using the specified equality comparer to compare values.
/// </summary>
/// <typeparam name="TSource">Source sequence element type.</typeparam>
/// <param name="source">Source sequence.</param>
/// <param name="comparerFactory">The definition of a comparer to compare elements.</param>
public static IEnumerable <TSource> DistinctUntilChanged <TSource>(this IEnumerable <TSource> source, Func <EqualityComparerBuilderFor <TSource>, IEqualityComparer <TSource> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TSource>());
return(source.DistinctUntilChanged(comparer));
}
/// <summary>
/// Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
/// <param name="first">First observable sequence to compare.</param>
/// <param name="second">Second observable sequence to compare.</param>
/// <param name="comparerFactory">The definition of a comparer to compare elements.</param>
public static IObservable <bool> SequenceEqual <TSource>(this IObservable <TSource> first, IObservable <TSource> second, Func <EqualityComparerBuilderFor <TSource>, IEqualityComparer <TSource> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TSource>());
return(first.SequenceEqual(second, comparer));
}
/// <summary>
/// Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function and comparer.
/// A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same
/// key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
/// <typeparam name="TKey">The type of the grouping key computed for each element in the source sequence.</typeparam>
/// <typeparam name="TDuration">The type of the elements in the duration sequences obtained for each group to denote its lifetime.</typeparam>
/// <param name="source">An observable sequence whose elements to group.</param>
/// <param name="keySelector">A function to extract the key for each element.</param>
/// <param name="durationSelector">A function to signal the expiration of a group.</param>
/// <param name="capacity">The initial number of elements that the underlying dictionary can contain.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IObservable <IGroupedObservable <TKey, TSource> > GroupByUntil <TSource, TKey, TDuration>(this IObservable <TSource> source, Func <TSource, TKey> keySelector, Func <IGroupedObservable <TKey, TSource>, IObservable <TDuration> > durationSelector, int capacity, Func <EqualityComparerBuilderFor <TKey>, IEqualityComparer <TKey> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TKey>());
return(source.GroupByUntil(keySelector, durationSelector, capacity, comparer));
}
/// <summary>
/// Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
/// <typeparam name="TKey">The type of the grouping key computed for each element in the source sequence.</typeparam>
/// <typeparam name="TElement">The type of the elements within the groups computed for each element in the source sequence.</typeparam>
/// <param name="source">An observable sequence whose elements to group.</param>
/// <param name="keySelector">A function to extract the key for each element.</param>
/// <param name="elementSelector">A function to map each source element to an element in an observable group.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IObservable <IGroupedObservable <TKey, TElement> > GroupBy <TSource, TKey, TElement>(this IObservable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <EqualityComparerBuilderFor <TKey>, IEqualityComparer <TKey> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TKey>());
return(source.GroupBy(keySelector, elementSelector, comparer));
}
public void SubstitutesCompareDefaultForNull()
{
IEqualityComparer <int> source = null;
var comparer = source.EquateSequence();
Assert.Equal(EqualityComparerBuilder.For <int>().Default().EquateSequence().ToString(), comparer.ToString());
}
/// <summary>
/// Creates a dictionary from a sequence according to a specified key selector function, a comparer, and an element selector function.
/// </summary>
/// <typeparam name="TSource">The type of the elements of the input sequence.</typeparam>
/// <typeparam name="TKey">The type of the keys returned by the key selector function.</typeparam>
/// <typeparam name="TElement">The type of the elements returned by the element selector function.</typeparam>
/// <param name="source">A sequence to create a dictionary from.</param>
/// <param name="keySelector">A function to extract the key for each element.</param>
/// <param name="elementSelector">A transform function to produce a result element value from each element.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <EqualityComparerBuilderFor <TKey>, IEqualityComparer <TKey> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TKey>());
return(source.ToDictionary(keySelector, elementSelector, comparer));
}
/// <summary>
/// Correlates the elements of two sequences based on matching keys. A specified equality comparer is used to compare keys.
/// </summary>
/// <typeparam name="TOuter">The type of the elements of the first sequence.</typeparam>
/// <typeparam name="TInner">The type of the elements of the second sequence.</typeparam>
/// <typeparam name="TKey">The type of the keys returned by the key selector functions.</typeparam>
/// <typeparam name="TResult">The type of the result elements.</typeparam>
/// <param name="outer">The first sequence to join.</param>
/// <param name="inner">The sequence to join to the first sequence.</param>
/// <param name="outerKeySelector">A function to extract the join key from each element of the first sequence.</param>
/// <param name="innerKeySelector">A function to extract the join key from each element of the second sequence.</param>
/// <param name="resultSelector">A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult>(this IEnumerable <TOuter> outer, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector, Func <EqualityComparerBuilderFor <TKey>, IEqualityComparer <TKey> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TKey>());
return(outer.Join(inner, outerKeySelector, innerKeySelector, resultSelector, comparer));
}
/// <summary>
/// Produces the set union of two sequences by using a specified equality comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
/// <param name="first">A sequence whose distinct elements form the first set for the union.</param>
/// <param name="second">A sequence whose distinct elements form the second set for the union.</param>
/// <param name="comparerFactory">The definition of a comparer to compare elements.</param>
public static IEnumerable <TSource> Union <TSource>(this IEnumerable <TSource> first, IEnumerable <TSource> second, Func <EqualityComparerBuilderFor <TSource>, IEqualityComparer <TSource> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TSource>());
return(first.Union(second, comparer));
}
/// <summary>
/// Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements of the sequence.</typeparam>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <typeparam name="TResult">The type of the result values.</typeparam>
/// <param name="source">A sequence whose elements are grouped.</param>
/// <param name="keySelector">A function to extract the key for each element.</param>
/// <param name="resultSelector">A function to create a result value from each group.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, Func <EqualityComparerBuilderFor <TKey>, IEqualityComparer <TKey> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TKey>());
return(source.GroupBy(keySelector, resultSelector, comparer));
}
/// <summary>
/// Determines whether a sequence contains a specified element by using a specified equality comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
/// <param name="source">A sequence in which to locate a value.</param>
/// <param name="value">The value to locate in the sequence.</param>
/// <param name="comparerFactory">The definition of a comparer to compare values.</param>
public static bool Contains <TSource>(this IEnumerable <TSource> source, TSource value, Func <EqualityComparerBuilderFor <TSource>, IEqualityComparer <TSource> > comparerFactory)
{
_ = comparerFactory ?? throw new ArgumentNullException(nameof(comparerFactory));
var comparer = comparerFactory(EqualityComparerBuilder.For <TSource>());
return(source.Contains(value, comparer));
}
public void SequenceHandlesNull()
{
var comparer = EqualityComparerBuilder.For <int?>().Default().EquateSequence(ignoreOrder: true);
Assert.True(comparer.Equals(new int?[] { 3, null }, new int?[] { null, 3 }));
Assert.Equal(comparer.GetHashCode(new int?[] { 3, null }), comparer.GetHashCode(new int?[] { null, 3 }));
}
public void ThenByIsOnlyAppliedAsTieBreaker()
{
IEqualityComparer <Person> thenByComparer = new FailComparer <Person>();
var comparer = EqualityComparerBuilder.For <Person>().Default().ThenEquateBy(thenByComparer);
Assert.False(comparer.Equals(AbeAbrams, CaseyJohnson));
Assert.False(comparer.Equals(CaseyJohnson, AbeAbrams));
}
public void NullSequenceNotEqualToEmptySequence()
{
var comparer = EqualityComparerBuilder.For <int[]>().Reference();
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.False(comparer.Equals(null, new int[0]));
Assert.False(objectComparer.Equals(null, new int[0]));
}
public void NullIsNotEqualToValue()
{
var comparer = EqualityComparerBuilder.For <int?>().Default();
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.False(comparer.Equals(3, null));
Assert.False(objectComparer.Equals(3, null));
}
public void ShorterGenericICollectionIsNotEqualToLongerGenericICollectionIfElementsAreEqual()
{
var e34 = new GenericICollection <int>(E_3_4().ToList());
var e345 = new GenericICollection <int>(E_3_4_5().ToList());
Assert.False(EqualityComparerBuilder.For <int>().Default().EquateSequence().Equals(e34, e345));
Assert.False(EqualityComparerBuilder.For <int>().Default().EquateSequence().Equals(e345, e34));
}
public void SequenceHandlesNullInEquivalenceClass()
{
var comparer = EqualityComparerBuilder.For <int?>().EquateBy(x => x ?? 0, specialNullHandling: true).EquateSequence(ignoreOrder: true);
Assert.True(comparer.Equals(new int?[] { 3, null }, new int?[] { 0, 3 }));
Assert.True(comparer.Equals(new int?[] { null, 3 }, new int?[] { 3, 0 }));
Assert.Equal(comparer.GetHashCode(new int?[] { 3, null }), comparer.GetHashCode(new int?[] { 0, 3 }));
}
public void EqualValueTypesAreNotEqual()
{
var comparer = EqualityComparerBuilder.For <int>().Reference();
var objectComparer = comparer as System.Collections.IEqualityComparer;
var value = 13;
Assert.False(comparer.Equals(value, value));
Assert.False(objectComparer.Equals(value, value));
}
public void NullIsNotEqualToValue()
{
var comparer = EqualityComparerBuilder.For <object>().Reference();
var objectComparer = comparer as System.Collections.IEqualityComparer;
var obj = new object();
Assert.False(comparer.Equals(obj, null));
Assert.False(objectComparer.Equals(obj, null));
}
public void OrderBySortsNullsAsNotEqualToValues()
{
var comparer = EqualityComparerBuilder.For <Person>().EquateBy(p => p.LastName);
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.False(comparer.Equals(JackAbrams, null));
Assert.False(objectComparer.Equals(JackAbrams, null));
Assert.False(comparer.Equals(JackAbrams, Jacknull));
Assert.False(objectComparer.Equals(JackAbrams, Jacknull));
}
public void OrderByWithNullPassesNullThrough()
{
var comparer = EqualityComparerBuilder.For <Person>().EquateBy(p => 0, specialNullHandling: true);
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.True(comparer.Equals(JackAbrams, null));
Assert.True(objectComparer.Equals(JackAbrams, null));
Assert.Equal(comparer.GetHashCode(JackAbrams), comparer.GetHashCode(null));
Assert.Equal(objectComparer.GetHashCode(JackAbrams), objectComparer.GetHashCode(null));
}
public void ForFuncT_ReturnsBuilderForT_WithoutInvokingFunc()
{
var result = EqualityComparerBuilder.For(() =>
{
throw new Exception();
return(3);
});
Assert.IsType <EqualityComparerBuilder <int> >(result);
}
public void UsesReferenceEqualityComparerForSequences()
{
var threeA = new[] { 3 };
var threeB = new[] { 3 };
var comparer = EqualityComparerBuilder.For <int[]>().Reference();
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.False(comparer.Equals(threeA, threeB));
Assert.False(objectComparer.Equals(threeA, threeB));
}
public void ComparesUnequalElementsAsEqual()
{
var comparer = EqualityComparerBuilder.For <int>().Null();
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.True(comparer.Equals(13, 17));
Assert.True(objectComparer.Equals(13, 17));
Assert.Equal(comparer.GetHashCode(13), comparer.GetHashCode(17));
Assert.Equal(objectComparer.GetHashCode(13), objectComparer.GetHashCode(17));
}
public void NullSequenceIsEqualToNullSequence()
{
var comparer = EqualityComparerBuilder.For <int[]>().Reference();
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.Equal(comparer.GetHashCode(null), comparer.GetHashCode(null));
Assert.Equal(objectComparer.GetHashCode(null), objectComparer.GetHashCode(null));
Assert.True(comparer.Equals(null, null));
Assert.True(objectComparer.Equals(null, null));
}
public void IdenticalObjectsAreEqual()
{
var comparer = EqualityComparerBuilder.For <object>().Reference();
var objectComparer = comparer as System.Collections.IEqualityComparer;
var obj = new object();
Assert.Equal(comparer.GetHashCode(obj), objectComparer.GetHashCode(obj));
Assert.True(comparer.Equals(obj, obj));
Assert.True(objectComparer.Equals(obj, obj));
}
public void NullIsEqualToNull()
{
var comparer = EqualityComparerBuilder.For <int?>().Default();
var objectComparer = comparer as System.Collections.IEqualityComparer;
Assert.Equal(comparer.GetHashCode(null), comparer.GetHashCode(null));
Assert.Equal(objectComparer.GetHashCode(null), objectComparer.GetHashCode(null));
Assert.True(comparer.Equals(null, null));
Assert.True(objectComparer.Equals(null, null));
}