c# List 里面的Linq方法

虽然List里的linq方法（其实是Enumarable的）大部分比较简单 ，但是如果能够灵活运用也是提高code质量，可读性和coding能力的有效途径。而且其中有些方法,例如 Join, 光看注释可能会有点懵。 最近把他们go through了一遍。代码如下。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Linq;
using System.Collections.ObjectModel;
using System.Collections;
namespace ListMethodTest
{
public class TestItem
    {
public int number { get; set; }
public string str { get; set; }
//used for SelectMany
        public List<string> children { get; set; }
public override int GetHashCode()
        {
return number;
        }
    }
public class InnerClass
    {
public int id { get; set; }
public string name { get; set; }
    }
public class ChildTestItem : TestItem
    { }
public class ConvertTest
    {
public int a { get; set; }
    }
public partial class _Default : System.Web.UI.Page
    {
        List<TestItem> lst1 = new List<TestItem>();
protected void Page_Load(object sender, EventArgs e)
        {
            lst1.Add(new TestItem() { number = 3, str = "dsdfsf", children = new List<string>() { "c1", "c2" } });
            lst1.Add(new TestItem() { number = 1, str = "csdfsdf", children = new List<string>() { "c3", "c4" } });
            lst1.Add(new TestItem() { number = 2, str = "aasdfsdf" });
            lst1.Add(new TestItem() { number = 2, str = "222" });
int part = 3;
switch (part)
            {
case 1: Part1();break;
case 2: Part2(); break;
case 3: Part3(); break;
default: break;
            }
        }
private void Part3()
        {
int sum = lst1.Sum(x => x.number);
            List<TestItem> take = lst1.Take(3).ToList();
//同样 take前面的 
            List<TestItem> takewhile = lst1.TakeWhile(x => x.number == 3).ToList();
//key必须唯一
// Dictionary<int,TestItem> toDic=   lst1.ToDictionary(x => x.number);
//Ilookup:IEnumerable<TElement> this[TKey key] { get; }   所以可以有重key
            ILookup<int, TestItem> lookup = lst1.ToLookup(x => x.number);
//lst1.TrimExcess();
bool trueforall = lst1.TrueForAll(x => x.number > -1);
            List<TestItem> where = lst1.Where(x => x.number == 2).ToList();
        }
void Part2()
        {
// 里面的 item和原来的是一个引用，即便 不重写GetHashCode
            List<TestItem> getR = lst1.GetRange(1, 2);
            IEnumerable<IGrouping<int, TestItem>> gb = lst1.GroupBy(x => x.number);
int io = lst1.IndexOf(lst1[1]);
            lst1.Insert(0, new TestItem() { number = 0, str = "00" });
            List<TestItem> toInsert = new List<TestItem>()
            {
new TestItem() { number = 0, str = "InsertRange0"},
new TestItem() { number = 2, str = "InsertRange1" },
new TestItem() { number = 9, str = "InsertRange2" },
            };
//lst1.InsertRange(0, toInsert);
//返回 lst1中与  toInsert 相等的 元素 
            List<TestItem> Intersect = lst1.Intersect(toInsert, new DistinctTest()).ToList();
            List<InnerClass> inner = new List<InnerClass>() { 
new InnerClass(){ name1"},
new InnerClass(){ name2"},
new InnerClass(){ name3"},
            };
// 2个list的 TKEY 类型必须一致， 返回 key相等的组合 ，其实就是 key相等的 inner join
// 最后一个委托只是根据组合 生成 返回的结果
            IEnumerable join = lst1.Join(inner, x => x.number, i => i.id, (a, b) => new { a.number, a.str, b.id, b.name });
// 类似  dictionary,    lst1为key, 匹配的 InnerClass 的集合为value ，即使集合count为0(没有匹配) ,也会组合
            IEnumerable gj = lst1.GroupJoin(inner, x => x.number, i => i.id, (a, b) => new { id = a.number, name = a.str, lst = b });
            IEnumerable zip = lst1.Zip(inner, (x, y) => new { x.number, x.str, y.id, y.name });
            TestItem last = lst1.Last(x => x.number == 2);
int lindex = lst1.LastIndexOf(lst1[2]);
int max = lst1.Max(x => x.number);
int min = lst1.Min(x => x.number);
//lst1.Add(new ChildTestItem());
//IEnumerable<ChildTestItem>   ot=  lst1.OfType<ChildTestItem>();
            List<TestItem> ob = lst1.OrderBy(x => x.str).ToList();
//lst1.Sort((a, b) => {
//        if( a.number< b.number)  return -1;
//        else if( a.number == b.number) return 0;
//        else return 1;
//    } );
// TestItem temp =lst1[0];
// bool remove = lst1.Remove(temp);
// int  ra=    lst1.RemoveAll(x => x.number == 2);
// lst1.RemoveAt(2);
//lst1.RemoveRange(2, 2);
//lst1.Reverse();
// select 是变形用的 ，这个词太唬人了，别被他的外表所蒙蔽
            IEnumerable select = lst1.Select(x => new { id = x.number, name = x.str, g = Guid.NewGuid() });
            IEnumerable select1 = lst1.Select((x, y) => new { id = x.number, name = x.str, index = y, g = Guid.NewGuid() });
//flatten   IEnumerable{"c1","c2","c3","c4"}
            IEnumerable SelectMany = lst1.SelectMany(x => x.children == null ? new List<string>() : x.children);
            List<TestItem> s1 = new List<TestItem>()
           {
new TestItem(){  number=1 ,str="sdf" }
           };
            List<TestItem> s2 = new List<TestItem>()
           {
new TestItem(){  number=1  }
           };
//个数不一样肯定 false
            bool se = s1.SequenceEqual(s2, new DistinctTest());
            List<TestItem> union = s1.Union(s2).ToList();
//不single的话 throw exception
//TestItem singe = lst1.Single(x => x.number ==2);
            List<TestItem> skip = lst1.Skip(2).ToList();
//注意 bypass   前面的element
            List<TestItem> SkipWhile = lst1.SkipWhile(x => x.number == 0).ToList();
        }
void Part1()
        {
//  ( (item 1,2 的结果 )  和item 3的结果)和item 4的结果
            TestItem agg = lst1.Aggregate((i, j) => { i.number += j.number; return i; });
bool all = lst1.All(i => i.str.Contains("c"));
bool any = lst1.Any(i => i.str.Contains("c"));
            ParallelQuery p = lst1.AsParallel();
            IQueryable<TestItem> q = lst1.AsQueryable();
var query = from ti in q where ti.number == 2 select ti;
            ReadOnlyCollection<TestItem> readonlylst = lst1.AsReadOnly();
double average = lst1.Average(i => i.number);
int index = lst1.BinarySearch(new TestItem() { number = 1, str = "123123" }, new CompareClass());
//如果lst1是非泛型的集合 ，转换之后就可以用泛型的方法啦！ where, any ,select , all等
            IEnumerable<TestItem> castedLst = lst1.Cast<TestItem>();
            List<TestItem> lsttoConcat = new List<TestItem>() { new TestItem() { number = 4 } };
            List<TestItem> concatedLst = lst1.Concat(lsttoConcat).ToList();
            TestItem t = new TestItem() { number = 4 };
            lst1.Add(t);
//bool contains = lst1.Contains<TestItem>(t);
            bool contains = lst1.Contains<TestItem>(new TestItem() { number = 4 });
//bool contains = lst1.Contains<string>("sdfsdf");   it's wrong!
            List<ConvertTest> convertedLst = lst1.ConvertAll(i => new ConvertTest() { a = i.number });
            TestItem[] arr = new TestItem[10];
            lst1.CopyTo(arr, 3);
//下面defLst count 为 0
            IEnumerable<TestItem> defLst = lst1.DefaultIfEmpty();
            IEnumerable<TestItem> dsicLst = lst1.Distinct();
            lst1.Add(new TestItem() { number = 4, str = "sdfsd" });
            IEnumerable<TestItem> dsicLst1 = lst1.Distinct<TestItem>(new DistinctTest());
            TestItem elementat = lst1.ElementAt(1);
            TestItem elementatORDefault = lst1.ElementAtOrDefault(10);
            List<TestItem> toexcept = new List<TestItem>()
            {
                lst1[2],
                lst1[3]
            };
            IEnumerable<TestItem> exceptedLst = lst1.Except(toexcept);
bool exist = lst1.Exists(i => i.number == 4);
            TestItem find = lst1.Find(i => i.number == 4);
            List<TestItem> findall = lst1.FindAll(i => i.number == 4);
int fIndex = lst1.FindIndex(i => i.number == 4);
            TestItem fLast = lst1.FindLast(i => i.number == 4);
int lastIndex = lst1.FindLastIndex(i => i.number == 4);
            TestItem first = lst1.First(x => x.number == 4);
            lst1.ForEach(x => x.str = x.number == 4 ? "4" : x.str);
        }
    }
public class DistinctTest : IEqualityComparer<TestItem>
    {
public bool Equals(TestItem x, TestItem y)
        {
if (x.number == y.number) return true;
else return false;
        }
public int GetHashCode(TestItem obj)
        {
//HashCode默认情况就是地址的散列码，跟散列算法有关系,所以默认情况不同对象的hashcode是不一样的，所以要重写TestItem的GetHashCode方法。
//用最简单的方法来说，hashcode就是一个签名。当两个对象的hashcode一样时，两个对象就"有可能"一样。如果不一样的话两个对象就"肯定"不一样。
            return obj.GetHashCode();
        }
    }
public class CompareClass : IComparer<TestItem>
    {
public int Compare(TestItem x, TestItem y)
        {
if (x.number < y.number) return -1;
else if (x.number == y.number) return 0;
else return 1;
        }
    }
}