C# (CSharp) Smart.Collections.Generic Comparers Examples

Example #1

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TOuter"></typeparam>
 /// <typeparam name="TInner"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <typeparam name="TResult"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="outer"></param>
 /// <param name="inner"></param>
 /// <param name="outerKeySelector"></param>
 /// <param name="innerKeySelector"></param>
 /// <param name="resultSelector"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult, TCompareKey>(this IEnumerable <TOuter> outer, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector, Func <TKey, TCompareKey> compareKeySelector)
 {
     return(outer.Join(inner, outerKeySelector, innerKeySelector, resultSelector, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #2

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="first"></param>
 /// <param name="second"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static bool SequenceEqual <TSource, TCompareKey>(this IEnumerable <TSource> first, IEnumerable <TSource> second, Func <TSource, TCompareKey> compareKeySelector)
 {
     return(first.SequenceEqual(second, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #3

File: Comparers.Enumerable.Comparison.cs Project: wangzhefeng2000/Smart-Net-CE

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="comparison"></param>
 /// <returns></returns>
 public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey>(this IOrderedEnumerable <TSource> source, Func <TSource, TKey> keySelector, Comparison <TKey> comparison)
 {
     return(source.ThenByDescending(keySelector, Comparers.Comparison(comparison)));
 }

Example #4

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <typeparam name="TElement"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="elementSelector"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static IEnumerable <IGrouping <TKey, TElement> > GroupBy <TSource, TKey, TElement, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, TCompareKey> compareKeySelector)
 {
     return(source.GroupBy(keySelector, elementSelector, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #5

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="first"></param>
 /// <param name="second"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static IEnumerable <TSource> Except <TSource, TCompareKey>(this IEnumerable <TSource> first, IEnumerable <TSource> second, Func <TSource, TCompareKey> compareKeySelector)
 {
     return(first.Except(second, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #6

 public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey>(this IOrderedEnumerable <TSource> source, Func <TSource, TKey> keySelector, Comparison <TKey> comparison) =>
 source.ThenBy(keySelector, Comparers.Comparison(comparison));

Example #7

File: ComparersEnumerable.ProjectionEquality.cs Project: usausa/Smart-Net

 public static IEnumerable <TSource> Union <TSource, TCompareKey>(this IEnumerable <TSource> first, IEnumerable <TSource> second, Func <TSource, TCompareKey> compareKeySelector) =>
 first.Union(second, Comparers.ProjectionEquality(compareKeySelector));

Example #8

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="value"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static bool Contains <TSource, TCompareKey>(this IEnumerable <TSource> source, TSource value, Func <TSource, TCompareKey> compareKeySelector)
 {
     return(source.Contains(value, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #9

File: ComparersEnumerable.ProjectionEquality.cs Project: usausa/Smart-Net

 public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, TCompareKey> compareKeySelector)
     where TKey : notnull =>
 source.ToDictionary(keySelector, elementSelector, Comparers.ProjectionEquality(compareKeySelector));

Example #10

File: ComparersEnumerable.ProjectionEquality.cs Project: usausa/Smart-Net

 public static ILookup <TKey, TSource> ToLookup <TSource, TKey, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TCompareKey> compareKeySelector) =>
 source.ToLookup(keySelector, Comparers.ProjectionEquality(compareKeySelector));

Example #11

File: ComparersEnumerable.ProjectionEquality.cs Project: usausa/Smart-Net

 public static IEnumerable <IGrouping <TKey, TSource> > GroupBy <TSource, TKey, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TCompareKey> compareKeySelector) =>
 source.GroupBy(keySelector, Comparers.ProjectionEquality(compareKeySelector));

Example #12

File: ComparersEnumerable.Delegate.cs Project: usausa/Smart-Net

 public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey>(this IOrderedEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TKey, int> compare) =>
 source.ThenBy(keySelector, Comparers.Delegate(compare));

Example #13

File: ComparersEnumerable.Delegate.cs Project: usausa/Smart-Net

 public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TKey, int> compare) =>
 source.OrderByDescending(keySelector, Comparers.Delegate(compare));

Example #14

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TCompareKey> compareKeySelector)
 {
     return(source.ToDictionary(keySelector, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #15

File: Comparers.Enumerable.Delegate.cs Project: wangzhefeng2000/Smart-Net-CE

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="compare"></param>
 /// <returns></returns>
 public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TKey, int> compare)
 {
     return(source.OrderBy(keySelector, Comparers.Delegate(compare)));
 }

Example #16

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <typeparam name="TElement"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="elementSelector"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, TCompareKey> compareKeySelector)
 {
     return(source.ToLookup(keySelector, elementSelector, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #17

File: Comparers.Enumerable.Delegate.cs Project: wangzhefeng2000/Smart-Net-CE

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="compare"></param>
 /// <returns></returns>
 public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey>(this IOrderedEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, TKey, int> compare)
 {
     return(source.ThenByDescending(keySelector, Comparers.Delegate(compare)));
 }

Example #18

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static IEnumerable <TSource> Distinct <TSource, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TCompareKey> compareKeySelector)
 {
     return(source.Distinct(Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #19

File: Comparers.Enumerable.Comparison.cs Project: wangzhefeng2000/Smart-Net-CE

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="comparison"></param>
 /// <returns></returns>
 public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Comparison <TKey> comparison)
 {
     return(source.OrderBy(keySelector, Comparers.Comparison(comparison)));
 }

Example #20

 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TSource"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 /// <typeparam name="TResult"></typeparam>
 /// <typeparam name="TCompareKey"></typeparam>
 /// <param name="source"></param>
 /// <param name="keySelector"></param>
 /// <param name="resultSelector"></param>
 /// <param name="compareKeySelector"></param>
 /// <returns></returns>
 public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult, TCompareKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, Func <TKey, TCompareKey> compareKeySelector)
 {
     return(source.GroupBy(keySelector, resultSelector, Comparers.ProjectionEquality(compareKeySelector)));
 }

Example #21

 public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Comparison <TKey> comparison) =>
 source.OrderByDescending(keySelector, Comparers.Comparison(comparison));