/// <summary> /// 构造函数 /// </summary> /// <param name="needtoexcute">把已经转化成数组形式的数据源传入执行条件筛选形成key数组</param> /// <param name="keyselector">条件筛选方法</param> /// <param name="next">比较器的下一个引用</param> /// <param name="comparer">这个sorter的比较器</param> public MyOrderThenBySorter(TMySource[] needtoexcute, 内置委托.Func <TMySource, TMyKey> keyselector, MyOrderThenBySorter <TMySource, TMyKey> next, 系统内置接口.IComparer <TMyKey> comparer) { this.needtoexcute = needtoexcute; this.keyselector = keyselector; this.next = next; this.comparer = comparer; }
internal void Create <TSource>(数据结构.IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, 内置委托.Func <TSource, TElement> elementselector) { //对数据集合每个元素进行遍历 IEnumerator <TSource> tor = source.GetEnumerator(); while (tor.MoveNext()) { GetGrouping(keyselector(tor.Current), true).Add(elementselector(tor.Current)); } }
/// <summary> /// 判断某个集合中的所有的元素是否都匹配条件 /// </summary> /// <typeparam name="TSource"></typeparam> /// <param name="source"></param> /// <param name="predicate"></param> /// <returns></returns> public static bool All <TSource>(this IEnumerable <TSource> source, 内置委托.Func <TSource, bool> predicate) { if (source == null) { throw new Exception("源数据不能为空"); } if (predicate == null) { throw new Exception("条件不能为空"); } var tor = source.GetEnumerator(); while (tor.MoveNext()) { if (!predicate(tor.Current)) { return(false); } } return(true); }
/// <summary> /// 构造函数 /// </summary> /// <param name="source"></param> /// <param name="keyselector"></param> public OrderThenBySequence(数据结构.IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, 系统内置接口.IComparer <TKey> comparer) { if (source == null) { throw new Exception("需要排序的数据源不能为空"); } if (keyselector == null) { throw new Exception("需要排序的字段不能为空"); } this.comparer = comparer; this.source = source; this.keyselector = keyselector; this.parent = null;//如果是orderby那么就说明只需要创建一个序列,也就没有了父级序列 //如果用户没有定义默认的比较器就使用系统默认的比较器 if (this.comparer == null) { 数据结构.Comparer <TKey> comparerclass = new Comparer <TKey>(); this.comparer = comparerclass.Default; } }
/// <summary> /// 基本的ToLookup方法 /// </summary> /// <typeparam name="TKey">分组的键</typeparam> /// <typeparam name="TSource">数据源中的每一个实体</typeparam> /// <typeparam name="TElement">筛选后的数据</typeparam> /// <param name="source">数据源</param> /// <param name="keyselector">选择分组键的方法</param> /// <param name="elementselector">筛选要选取的数据</param> /// <param name="comparer">用户定义的比较器</param> /// <returns></returns> public static 系统内置接口.ILookup <TKey, TElement> ToLookup <TKey, TSource, TElement>(this IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, 内置委托.Func <TSource, TElement> elementselector, 系统内置接口.IEqualityComparer <TKey> comparer) { MyLookup <TKey, TElement> lookup = new MyLookup <TKey, TElement>(comparer); lookup.Create(source, keyselector, elementselector); return(lookup); }
public static 系统内置接口.ILookup <TKey, TElement> ToLookup <TKey, TSource, TElement>(this IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, 内置委托.Func <TSource, TElement> elementselector) { return(ToLookup(source, keyselector, elementselector, null)); }
public static 系统内置接口.ILookup <TKey, TSource> ToLookup <TKey, TSource>(this IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector) { return(ToLookup(source, keyselector, IdentityFunction <TSource> .Instance, null)); }
public static 系统内置接口.ILookup <TKey, TSource> ToLookup <TKey, TSource>(this IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, 系统内置接口.IEqualityComparer <TKey> comparer) { MyLookup <TKey, TSource> lookup = new MyLookup <TKey, TSource>(comparer); lookup.Create(source, keyselector, 数据结构.IdentityFunction <TSource> .Instance); return(lookup); }
public static int Max <TSource>(this IEnumerable <TSource> source, 内置委托.Func <TSource, bool> predicate) { return(1); }
public static System.Collections.Generic.IEnumerable <TResult> GroupBy <TSource, TKey, TResult>(this IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, Func <TKey, System.Collections.Generic.IEnumerable <TSource>, TResult> resultselector) { MyLookup <TKey, TSource> lookup = new MyLookup <TKey, TSource>(null); lookup.Create(source, keyselector, IdentityFunction <TSource> .Instance); return(lookup.StaticResult(resultselector)); }
public static 数据结构.IEnumerable <系统内置接口.IGrouping <TKey, TSource> > GroupBy <TSource, TKey>(this IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector, 内置委托.Func <TSource, TSource> elementselector, 系统内置接口.IEqualityComparer <TKey> comparer) { MyLookup <TKey, TSource> lookup = new MyLookup <TKey, TSource>(comparer); lookup.Create(source, keyselector, elementselector); return(lookup.GetPerGroup()); }
public static 数据结构.IEnumerable <系统内置接口.IGrouping <TKey, TSource> > GroupBy <TSource, TKey>(this IEnumerable <TSource> source, 内置委托.Func <TSource, TKey> keyselector) { MyLookup <TKey, TSource> lookup = new MyLookup <TKey, TSource>(null); lookup.Create(source, keyselector, IdentityFunction <TSource> .Instance); return(lookup.GetPerGroup()); }
public static IEnumerable <TSource> OrderByDescending <TSource>(this IEnumerable <TSource> source, 内置委托.Func <TSource, bool> predicate) { return(new MyList <TSource>()); }
public static TSorce SingleOrDefault <TSorce>(this IEnumerable <TSorce> source, 内置委托.Func <TSorce, bool> predicate) { return(default(TSorce)); }
public static IEnumerable <TSource> Where <TSource>(this IEnumerable <TSource> source, 内置委托.Func <TSource, int, bool> predicate) { if (source == null) { throw new Exception("源数据不能为空"); } if (predicate == null) { throw new Exception("条件不能为空"); } return(WhereAndIndexIterator(source, predicate)); }
/// <summary> /// Where筛选,Func中的参数是当前遍历到的元素和当前遍历到的元素的索引值 /// </summary> /// <typeparam name="TSource"></typeparam> /// <param name="source"></param> /// <param name="predicate"></param> /// <returns></returns> static IEnumerable <TSource> WhereAndIndexIterator <TSource>(IEnumerable <TSource> source, 内置委托.Func <TSource, int, bool> predicate) { MyList <TSource> list = new MyList <TSource>(); IEnumerator <TSource> tor = source.GetEnumerator(); int index = -1; while (tor.MoveNext()) { checked { index++; } if (predicate(tor.Current, index)) { list.Add(tor.Current); } } return(list); }
/// <summary> /// Where筛选,Func中的参数是当前元素 /// </summary> /// <typeparam name="TSource"></typeparam> /// <param name="source"></param> /// <param name="predicate"></param> /// <returns></returns> static IEnumerable <TSource> WhereIterator <TSource>(IEnumerable <TSource> source, 内置委托.Func <TSource, bool> predicate) { MyList <TSource> list = new MyList <TSource>(); IEnumerator <TSource> tor = source.GetEnumerator(); while (tor.MoveNext()) { if (predicate(tor.Current)) { list.Add(tor.Current); //yield return tor.Current;//应该是不能使用yield return,本来是这么写的,代码更加的优雅 } } return(list); }
/// <summary> ///当OrderBy之后进行ThenBy的序列的创建的时候调用的方法,接受必须进行OrderBy之后的参数(IOrderThenBy类型的参数) /// </summary> /// <param name="afterorderbysource">IOrderThenBy的数据类型</param> /// <param name="thenbyKeySelector">ThenBy需要执行的方法</param> /// <returns></returns> public 数据结构.OrderThenBySequence <TSource, TKey> CreateForThenBy(内置委托.Func <TSource, TKey> thenbyKeySelector, 系统内置接口.IComparer <TKey> comparer) { 数据结构.OrderThenBySequence <TSource, TKey> thenbysource = new OrderThenBySequence <TSource, TKey>(source, thenbyKeySelector, comparer); thenbysource.parent = this;//this表示的当前的类,某个类的实例的对象.方法,那么在这个方法中的this就是这个 实例对象 return(thenbysource); }