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