/// <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)); }