LINQ查询结果集

System.Array 数组

所有数组都继承于System.Array,数组可以用System.Array建立

数组可以是一维也可以是多维数组。"维数"对应于用来识别每个数组元素的下标个数。维数可以多达 32 维。 数组的每一维都有一个非零的长度。在数组的每一维中，数组元素按下标 0 到该维最高下标值连续排列.数组没有固定大小。数组在创建以后仍可以改变大小。

数组是对象，因此每种数组类型都是一个单独的引用类型。这意味着：

1.数组变量中含有指向数据的指针，这些数据包含元素、秩和长度信息。

2.在将一个数组变量赋值给另一个数组变量时，只有指针进行了复制。

3.两个数组变量只有在具有相同的维数和元素数据类型时，才能看成是同一数据类型的数组变量。

基于System.Array定义数组

基于类型定义数组

数组元素的清空

System.Array类静态成员

不用循环填充数组

string[] v = new string[50]; v[0] = "wxwinter"; System.Collections.ArrayList.Repeat(v[0], v.Length).CopyTo(v);

泛型方法见集合的实例泛型方法

数组类实例成员

扩展方法见集合扩展方法

System.Collections 集合

ArrayList

System.Collections

一个数组型集合，使用的是随顺存储

实例成员

静态成员

List

System.Collections.Generic

除ArrayList方法外

ConvertAll

public List ConvertAll (Converter<T,TOutput> converter)

创建复本

调用委托System.Converter< TInput,TOutput>public delegate TOutput Converter<TInput, TOutput>(TInput input);将对象从一种类型转换为另一种类型的方法

1. 将当前 List 中的元素转换为另一种类型，并返回包含转换后的元素的列表

1. 将当前 List 中的元素值批量修改

static void Main(string[] args){List ls = new List() { "1", "2", "3" };List li = ls.ConvertAll(stringAdd);} public static string stringAdd(string s){return s+"wxd";}

ForEach

public void ForEach ( Action action)

对 List 的每个元素执行指定操作

调用委托System.Action public delegate void Action (T obj)对传递给它的对象执行某个操作的方法的委托

Find、FindLast、FindIndex、FindLastIndex、Exists、TrueForAll

public T Find (Predicate match)

检索与条件匹配的所有元素，并返回整个 List 中的第一个匹配元素，其中包含与指定谓词所定义的条件相匹配的所有元素；否则为一个空 List

创建复本

FindLast 返回索引值 public T FindLast ( Predicate match)

FindIndex 返回索引值 public int FindIndex ( Predicate match)

FindLastIndex 返回逻辑型 public int FindLastIndex ( Predicate match)

Exists 返回逻辑型 public bool Exists ( Predicate match)

TrueForAll 返回逻辑型，确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配 public bool TrueForAll ( Predicate match)

调用委托System.Predicatepublic delegate bool Predicate(T obj);定义一组条件并确定指定对象是否符合这些条件的方法

FindAll

public List FindAll (Predicate match)

检索与条件匹配的所有元素，如果找到，则为一个 List，其中包含与指定谓词所定义的条件相匹配的所有元素；否则为一个空 List

创建复本

调用委托System.Predicatepublic delegate bool Predicate(T obj);定义一组条件并确定指定对象是否符合这些条件的方法

RemoveAll

public int RemoveAll (Predicate match)

移除与指定条件相匹配的所有元素。

调用委托System.Predicatepublic delegate bool Predicate(T obj);定义一组条件并确定指定对象是否符合这些条件的方法

Sort

public void Sort ( Comparison comparison)

对 List 或它的一部分中的元素进行排序

Sort （）方法见 System.IComparable接口、System.IComparable接口

Sort (IComparer) 方法见 System.Collections.IComparer 接口、System.Collections.Generic.IComparer 接口

调用委托System.Comparisonpublic delegate int Comparison (T x,T y)表示比较同一类型的两个对象的方法x 小于 y 返回小于0的负数x 等于 y 返回0x 大于 y 返回大于0的正数

Hashtable

System.Collections

System.Collections.DictionaryEntry 结构 字典键/值对

散列表（也叫哈希表），是根据关键码值直接进行访问的数据结构，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

哈希表使用的是链式存储

哈希表使用键值对的方式来存储

哈希表中，键名不能重复

SortedList

System.Collections

SortedList将ArrayList与Hashtable的功能集成

SortedList<TKey,TValue>

System.Collections.Generic

//System.IComparable//定义通用的比较方法，由值类型或类实现以创建类型特定的比较方法。class a : System.IComparable{public a(string va,int le){s = va;l = le;}public string s;public int l; //实现System.IComparable.CompareTopublic int CompareTo(object obj){if (object.Equals(this, obj)){return 0;}else{return 1;}}} //使用System.Collections.Generic.SortedList<a, System.Windows.Forms.TextBox> jh=new SortedList<a,TextBox>();a k1 = new a("123",0);a k2 = new a("456",100);a k3 =new a("789",200); jh.Add(k1, new TextBox());jh.Add(k2, new TextBox());jh.Add(k3, new TextBox()); //值操作foreach (TextBox tp in jh.Values){this.Controls.Add(tp);} //键操作foreach (a tp in jh.Keys){tp.s = "ok";} //键值对操作foreach (System.Collections.Generic.KeyValuePair<a, TextBox> tp in jh){tp.Value.Text = tp.Key.s;tp.Value.Left = tp.Key.l;} //通过键操作值jh[k2].Text = "hello";

Queue

System.Collections.Generic

class a{public a(string v){s = v;}public string s;} //使用System.Collections.Generic.Queue jh = new Queue(); //入队jh.Enqueue(new a("a"));jh.Enqueue(new a("b"));jh.Enqueue(new a("c")); //出队:每执行一次出一个if (0 != jh.Count){a obj = jh.Dequeue();System.Console.WriteLine(obj.s);}

Stack

System.Collections.Generic

class a{public a(string v){s = v;}public string s;} //使用System.Collections.Generic.Stack jh = new Stack(); //入栈jh.Push(new a("a"));jh.Push(new a("b"));jh.Push(new a("c")); //出栈:每执行一次出一个if (0 != jh.Count){a obj = jh.Pop();System.Console.WriteLine(obj.s);}

LinkedList

System.Collections.Generic

class a{public a(string v){s = v;}public string s;} //使用System.Collections.Generic.LinkedList lb = new LinkedList();System.Collections.Generic.LinkedListNode p; void 添加结点(){p = new LinkedListNode(new a("1"));lb.AddFirst(p);lb.AddAfter(lb.First, new a("2"));lb.AddBefore(lb.First, new a("3"));lb.AddLast(new a("4"));lb.AddFirst(new a("5"));} void 读取头尾结点(){string fs = lb.First.Value.s;string ls = lb.Last.Value.s;System.Console.WriteLine(fs +ls);} void 下一节点(object sender, EventArgs e){p = p.Next;if (p == null){System.Console.WriteLine("到达边界");}else{System.Console.WriteLine(p.Value.s);}} void 上一结点(){p = p.Previous;if (p == null){System.Console.WriteLine("到达边界");}else{System.Console.WriteLine(p.Value.s);}}

System.Collections.Generic.HashSet h = new HashSet(); // h.Add(1);h.Add(1); //不报错h.Add(1);//不报错h.Add(2);h.Add(2);//不报错h.Add(3); //只显示//1//2//3 foreach (var v in h){System.Console.WriteLine(v);}

System.Linq

System.Linq.Enumerable

System.Linq.Queryable

System.Linq.Lookup <TKey,TElement>

System.Linq.Expressions.Expression

public delegate TR lzm<T, TR>(T v1);class Program{static void Main(string[] args){System.Linq.Expressions.Expression<lzm<int, bool>> ep;ep = le => le > 123;}}

接口

IEnumerable 、IEnumerator

System.Collections

正常使用

C#的 yield

当编译器检测到迭代器时，它将自动生成 IEnumerable 或 IEnumerable 接口的 Current、MoveNext 和 Dispose 方法

省去了写System.Collections.IEnumerator的代码

yield return expression1;yield return expression2;yield return expression3;yield break; //将终止迭代，后面的迭代将不输出yield return expression4;

IEnumerable

System.Collections.Generic

公开枚举数，该枚举数支持在指定类型的集合上进行简单迭代。

IEnumerator

System.Collections.Generic

支持在泛型集合上进行简单迭代。

ICollection

System.Collections

ICollection 接口是 System.Collections 命名空间中类的基接口。

ICollection 接口扩展 IEnumerable；IDictionary 和 IList 则是扩展 ICollection 的更为专用的接口。IDictionary 实现是键/值对的集合，如 Hashtable 类。IList 实现是值的集合，其成员可通过索引访问，如 ArrayList 类。

某些集合（如 Queue 类和 Stack 类）限制对其元素的访问，它们直接实现 ICollection 接口。

如果 IDictionary 接口和 IList 接口都不能满足所需集合的要求，则从 ICollection 接口派生新集合类以提高灵活性。

ICollection

System.Collections.Generic

定义操作泛型集合的方法。

IList

System.Collections

IList 是 ICollection 接口的子代，并且是所有非泛型列表的基接口。IList 实现有三种类别：只读、固定大小和可变大小。无法修改只读 IList。固定大小的 IList 不允许添加或移除元素，但允许修改现有元素。可变大小的 IList 允许添加、移除和修改元素。

IList

System.Collections.Generic

表示可按照索引单独访问的一组对象。

IEqualityComparer

System.Collections

对象的相等比较

IEqualityComparer

System.Collections.Generic

定义方法以支持对象的相等比较。

IDictionary

System.Collections

键/值对基接口

IDictionary <TKey,TValue>

System.Collections.Generic

表示键/值对的泛型集合。

IDictionaryEnumerator

System.Collections

枚举字典的元素

IComparer

System.Collections

比较两个对象的方法

接口方法说明 int Compare(object x, object y)

int Compare(object x, object y)方法的返回值小于零 : x小于 y零 : x等于y大于零 : x大于 y。

ArrayList.Sort (IComparer) 方法

class Program{static void Main(string[] args){ArrayList ls = new ArrayList() { new wxd { value = 4 }, new wxd { value = 2 }, new wxd { value = 1 }, new wxd { value = 3 } };ls.Sort(new wxd());}} class wxd : System.Collections.IComparer{public int value;public int Compare(object x, object y){int v = ((wxd)x).value - ((wxd)y).value;return v;}}

IComparer

System.Collections.Generic

定义类型为比较两个对象而实现的方法。

接口方法override int Compare(T x, T y)说明

override int Compare(T x, T y)方法的返回值小于零 : x小于 y零 : x等于y大于零 : x大于 y。

List.Sort (IComparer) 方法

class Program{static void Main(string[] args){List ls = new List { new wxd { value = 4 }, new wxd { value = 2 }, new wxd { value = 1 }, new wxd { value = 3 } };ls.Sort(new wxd());}} class wxd : System.Collections.Generic.Comparer{public int value;public override int Compare(wxd x, wxd y){int v = x.value - y.value;return v;}}

System.Linq.IGrouping

System.Linq.ILookup<TKey,TElement>

System.Linq.IOrderedEnumerable

System.Linq.IOrderedQueryable

System.Linq.IOrderedQueryable

System.Linq.IQueryable

System.Linq.IQueryable

System.Linq.IQueryProvider

集合扩展方法

集合扩展方法的实现:一个Where的例子

public class a{public int ID { get; set; }public string Name { get; set; }public static void Main(){List list = new List { new a { ID = 1, Name = "wxd" }, new a { ID = 2, Name = "lzm" }, new a { ID = 3, Name = "wxwinter" } }; var l1 = list.WxdWhere(le => le.Name == "lzm"); // 上面的（Lambda表达式）等同于下面的（匿名方法） IEnumerable l2 = list.WxdWhere(delegate(a le) { return le.Name == "lzm"; }); //与调用系统Where一样var l3 = list.Where(le => le.Name == "lzm");} } public static class e{// 相关委托public delegate TResult Func<T, TResult>(T arg); //相关Where扩展方法//Func<TSource, bool>：接受一个类型为TSource的参数//Func<TSource, bool>：某个需要满足的条件，返回bool值public static IEnumerable WxdWhere(this IEnumerable source, Func<TSource, bool> predicate){foreach (TSource item in source){if (predicate(item)){yield return item;}}}}

SelectMany 选择

Lambda表达式	List ls = new List() { "wxd/1", "lzm/2", "wxwinter/3" };var li = ls.SelectMany(p => p.Split('/'));foreach (var s in li){Console.WriteLine(s);}
对应Select效果	var ll = ls.Select(p => p.Split('/'));foreach (var s in ll){foreach (var ss in s){Console.WriteLine(ss);}}

Where 条件

与FindAll不一样，该方法以视图形式反回集合，不创建复本

List ls = new List() { 1, 2, 3, 4, 5 };var li = ls.Where(i => i < 3); //li中此时只有1,2ls[0] = 333; //1已改为333，li中此时只有2

OrderBy 排序升

与Sort不一样，以视图形式，不创建复本，不改变原集合的顺序

List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = ls.OrderBy(i => i);//----ls[1] = 6666;ls.Add(-5);//---li中的顺序已重新排列

OrderByDescending 排序降

GroupBy 分组

该方法分组结果集合

System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>

Join 联合查询

Lambda表达式

static void Main(string[] args){List ls1 = new List { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };List ls2 = new List { new T2 { ID = "a", bak = "hello" }, new T2 { ID = "a", bak = "wxwinter" }, new T2 { ID = "c", bak = "lzm" }, }; //返回一个新的匿名类的集合var li=ls1.Join(ls2,temp1=>temp1.Name,temp2=>temp2.ID,(temp1,temp2)=>new { temp1.Name, temp1.Value, temp2.ID, temp2.bak }); foreach (var s in li){Console.WriteLine("{0}-{1}-{2}-{3}", s.Name, s.ID, s.Value, s.bak);}}} public class T1{public string Name;public int Value;}public class T2{public string ID;public string bak;}

Linq同类功能

//返回一个新的匿名类的集合var li = from temp1 in ls1 join temp2 in ls2 on temp1.Name equals temp2.ID select new { temp1.Name, temp1.Value, temp2.ID, temp2.bak };

GroupJoin

Lambda表达式

static void Main(string[] args){List ls1 = new List { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };List ls2 = new List { new T2 { ID = "a", bak = "hello" }, new T2 { ID = "a", bak = "wxwinter" }, new T2 { ID = "c", bak = "lzm" }, }; //返回一个新的匿名类的集合var li = ls1.GroupJoin(ls2, temp1 => temp1.Name, temp2 => temp2.ID, (temp1, temp2) => new { temp1.Name, temp1.Value, 个数 = temp2.Count() });foreach (var s in li){Console.WriteLine("Name :{0},共有:{1}",s.Name,s.个数.ToString());} }} public class T1{public string Name;public int Value;}public class T2{public string ID;public string bak;}

Linq同类功能

//返回一个新的匿名类的集合var li = from temp1 in ls1join temp2 in ls2 on temp1.Name equals temp2.IDinto newtabselect new { temp1.Name, temp1.Value, 个数 = newtab.Count() };

Take 获取集合的前n个元素

//以视图形式，不创建复本 List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = ls.Take(5); //li[1, 3, 2, 4, 5] ls.Insert(0, 999); //li[999,1, 3, 2, 4]

Skip 跳过集合的前n个元素

List ls = new List() { 1, 3, 2, 2, 5, 2, 8, 1,50 };var li = ls.Skip(5);

Distinct 过滤集合中的相同项

List ls = new List() { 1, 3, 2, 2, 5, 2, 8, 1 };var li = ls.Distinct();

Union 连接不同集合，自动过滤相同项

List ls1 = new List() { 1, 3, 2, 2, 5, 2, 8, 1 };List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 }; var li = ls1.Union(ls2);

Concat 连接不同集合，不会自动过滤相同项

List ls1 = new List() { 1, 3, 2, 2, 5, 2, 8, 1 };List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 }; var li = ls1.Concat(ls2);

Intersect 获取不同集合的相同项（交集）

List ls1 = new List() { 1, 3, 2, 2, 5, 2, 8, 1,50 };List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 }; var li = ls1.Intersect(ls2);

Except 从某集合中删除其与另一个集合中相同的项

List ls1 = new List() { 1, 3, 2, 2, 5, 2, 8, 1,50 };List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 }; var li = ls1.Except(ls2);

Reverse 反转集合

List ls = new List() { 1, 3, 2, 2, 5, 2, 8, 1,50 }; ls.Reverse();

TakeWhile 条件第一次不成立就跳出循环

List ls = new List() { 1, 3, 2, 2, 5, 2, 8, 1,50 };var li =ls.TakeWhile(p=>p<4);

SkipWhile 条件第一次不成立就失效，将后面的数据全取

List ls = new List() { 1, 2, 3, 4, 5, 6, 7, 8,9 ,1,2,3};var li =ls.SkipWhile(p=>p<=3);

Cast 将集合转换为强类型集合

ArrayList ls1 = new ArrayList {"a","b","1" }; // ArrayList ls1 = new ArrayList { "a", "b", 1 }; //下面的转换会报错 // List ls2 = (List)ls1; //编译会报错 // List ls3 = (List)ls1.Cast(); //运行会报错 var ls4 = ls1.Cast(); List ls5 = ls1.Cast().ToList();

OfType 过滤集合中的指定类型

ArrayList ls1 = new ArrayList {"a","b","c",1 };var ls4 = ls1.OfType().Cast(); ls1[0] = 345; foreach (object s in ls4){System.Console.WriteLine(s);}

不延迟(浅复本)

Single 集合中符合条件的唯一元素，浅复本

得到的是复本

集合中没有会报错

集合中有两个以上会报错

List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8 }; var v = ls2.Single(p => p==1); //如果集合中没有,或有两个以上会报错,

SingleOrDefault 集合中符合条件的唯一元素（没有则返回类型默认值）,浅复本

得到的是复本

集合中没有则返回类型默认值

集合中有两个以上会报错

List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8 }; var v = ls2.SingleOrDefault(p => p == 1); //集合中有两个以上会报错,集合中没有则返回类型默认值

First 集合的第一个元素,浅复本

得到的是复本

集合中没有会报错

List ls = new List() { 1, 3, 2, 2, 5, 2, 8 }; var o = ls.First(); //第一 var o1 = ls.First(p=>p>2); //第一个大于2的

FirstOrDefault 集合中的第一个元素（没有则返回类型默认值）,浅复本

得到的是复本

集合中没有则返回类型默认值

List ls = new List() { 1, 3, 2, 2, 5, 2, 8 }; var o = ls.FirstOrDefault(); //第一个 var o1 = ls.FirstOrDefault(p => p > 2); //第一个大于2的

Last 集合中的最后一个元素,浅复本

得到的是复本

集合中没有会报错

List ls = new List() { 1, 3, 2, 2, 5, 2, 8,1 }; var o = ls.Last(); //最后一个 var o1 = ls.Last(p => p > 2); //最后一个大于2的

LastOrDefault 集合中的最后一个元素（没有则返回类型默认值）,浅复本

得到的是复本

集合中没有则返回类型默认值

List ls = new List() { 1, 3, 2, 2, 5, 2, 8,1 }; var o = ls.LastOrDefault(); //最后一个 var o1 = ls.LastOrDefault(p => p > 2); //最后一个大于2的

ElementAt 集合中指定索引的元素,浅复本

得到的是复本

集合中没有会报错

List ls = new List() { 1, 3, 2, 2, 5, 2, 8,1 };var o = ls.ElementAt(1);

ElementAtOrDefault 集合中指定索引的元素（没有则返回类型默认值）,浅复本

得到的是复本

集合中没有则返回类型默认值

List ls = new List() { 1, 3, 2, 2, 5, 2, 8,1 };var o = ls.ElementAtOrDefault(100);

Contains 判断集合中是否包含有某一元素

public class a{static void Main(string[] args){List ls2 = new List { new T2 { ID = "a", bak = "hello" }, new T2 { ID = "a", bak = "wxwinter" }, new T2 { ID = "c", bak = "lzm" }, };T2 obj = new T2() { bak = "sss", ID = "ok" };ls2.Add(obj);bool b = ls2.Contains(obj); //true 更多肉容见对像比效}} public class T2{public string ID;public string bak;}

Any 判断集合中是否有元素满足某一条件

public class a{static void Main(string[] args){List ls2 = new List { new T2 { ID = "a", bak = "hello" }, new T2 { ID = "a", bak = "wxwinter" }, new T2 { ID = "c", bak = "lzm" }, };bool b1 = ls2.Any(p => p.bak.Contains("ell") ); //truebool b2 = ls2.Any(p => p.ID=="a" ); //true }} public class T2{public string ID;public string bak;}

All 判断集合中是否所有元素都满足某一条件

public class a{static void Main(string[] args){List ls2 = new List { new T2 { ID = "a", bak = "hello" }, new T2 { ID = "a", bak = "wxwinter" }, new T2 { ID = "c", bak = "lzm" }, };bool b1 = ls2.All(p => p.bak.Contains("e") );//falsebool b2 = ls2.All(p => p.ID.Length ==1 ); //true }} public class T2{public string ID;public string bak;}

SequenceEqual 判断两个集合内容是否相同

List ls1 = new List() { 1, 3, 2, 2, 5, 2, 8, 1 };List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8, 1 }; bool b1 = ls2.SequenceEqual(ls1); //true

Count 、LongCount集合中的元素个数

List ls2 = new List() { 1, 3, 2, 2, 5, 2, 8, 1 }; int b1 = ls2.Count(p => p < 3); //5int b2 = ls2.Count(); //8

Average 、Sum集合平均值求和

Max、Min 集合最大值，最小值

Aggregate 根据输入的表达式获取一个聚合值

DefaultIfEmpty 查询结果为空则返回默认值,浅复本

如果集合是的无素为空(count==0),就向集合中插入一个默认元素

List ls3 = new List() { "wxd","lzm","wxwinter" ,"wxd"}; var ls4 = ls3.Where(p => p == "ok").DefaultIfEmpty("not"); ; //如果不存在返回给集合一个自定义的对象

ToArray 将集合转换为数组,浅复本

List ls3 = new List() { "wxd","lzm","wxwinter" ,"wxd"};string[] ss = ls3.ToArray();

ToList 将集合转换为List集合,浅复本

ToDictionary 将集合转换为<K, V>集合,浅复本

public class a{static void Main(string[] args){List ls1 = new List { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 4 } };System.Collections.Generic.Dictionary<string, T1> dd = ls1.ToDictionary(p => p.Name); var d = ls1.ToDictionary(p => p.Name); //如果集合中有值相同的Name,将报错//指定对象为键，原集合中的对象为值 foreach (var s in dd){System.Console.WriteLine(s);}} } public class T1{public string Name;public int Value;}

末整理方法

AsQueryable

Lambda表达式

Lambda表达式是委托的一种实现方式。与匿名方法类似。

格式

例1(比效)

例2(多参)

public delegate T lzm<T1, T2, T>(T1 v1, T2 v2); class a{public void f(lzm<int, int, int> func,int x,int y){int b = func(x, y);System.Console.WriteLine(b);}}class Program{static void Main(string[] args){a obj = new a();obj.f((v1, v2) => v1 - v2,100,200);Console.Read();}}

例3（list.Where）

public class a{public int ID { get; set; }public string Name { get; set; }public static void Main(){List list = new List { new a { ID = 1, Name = "wxd" }, new a { ID = 2, Name = "lzm" }, new a { ID = 3, Name = "wxwinter" } }; var l1 = list.WxdWhere(le => le.Name == "lzm"); // 上面的（Lambda表达式）等同于下面的（匿名方法） IEnumerable l2 = list.WxdWhere(delegate(a le) { return le.Name == "lzm"; }); //与调用系统Where一样var l3 = list.Where(le => le.Name == "lzm");} } public static class e{// 相关委托public delegate TResult Func<T, TResult>(T arg); //相关Where扩展方法//Func<TSource, bool>：接受一个类型为TSource的参数//Func<TSource, bool>：某个需要满足的条件，返回bool值public static IEnumerable WxdWhere(this IEnumerable source, Func<TSource, bool> predicate){foreach (TSource item in source){if (predicate(item)){yield return item;}}}}

public class a{ static void Main(string[] args){List<Func> list = new List<Func>(); for (int i = 0; i < 3; i++){//int temp = i;// list.Add(() => temp); // 1,2,3 这个temp，就称为lifting。lift是美语中的电梯，翻译为梯子或垫脚石，比较妥帖 list.Add(() => i); //3,3,3} foreach (var item in list){Console.WriteLine(item());}}}
所盼望输出，0，1，2，而实际结果是3,3,3。两个原因。第一，在for循环中，只能有一个 i 变量。即再第一次循环时，i 的地址就分配好了，不会因为循环次数的多少而发生任何改变，其改变的只能是里面装载的值。 第二，lambda表达式在构造时，传进去的是变量的地址，而不是具体值。只有当真正执行这个lambda表达式时，才会去确定它的值。这就是为什么上面的例子中，其结果均为3。（for循环在最后，又给 i 加了1） 在for循环中，定义一临时变量temp存储 i的值即可。因为编译器会对该临时变量重新分配内存，这样，每次循环，都重新分配新的内存，就不会有这个问题

QuerySyntax 查询语法

1. 查询句法是使用标准的LINQ查询运算符来表达查询时一个方便的声明式简化写法

   每个查询表达式的句法从from子句开始，以select或group子句结束

结果集合 = from 临时变量 in 要查询的集合 [....] select 返回内容; [结果集合]的类型与[select 返回内容]的类型一样[....] 其它关键字

1. 查询句法返回的类型是 System.Collections.IEnumerable 、 System.Collections.Generic.IEnumerable

public class a{static void Main(string[] args){List ls = new List { new T { Name = "a", Value = 1 }, new T { Name = "b", Value = 2 }, new T { Name = "c", Value = 3 }, }; var l1 = from temp in ls select temp; var l2 = from temp in ls select "姓名:" + temp.Name ; var l3 = from temp in ls where temp.Value <= 2 select temp; System.Collections.IEnumerable l4 = from temp in ls where temp.Value <= 2 select temp; System.Collections.Generic.IEnumerable l5 =from temp in ls where temp.Value <= 2 select temp;} } public class T{public string Name;public int Value;}

3.结果集合以视图方式返回，源集合的内容改变后，会反映到结果集合上。在Select时New全新的对像也是这种情况，因为[结果集合]是动态的，每次访问都按查询句重新生成

public class a{static void Main(string[] args){List ls = new List { new T { Name = "a", Value = 1 }, new T { Name = "b", Value = 2 }, new T { Name = "c", Value = 3 }, };var l3 = from temp in ls select new T2 { x=temp.Name , y=temp.Value , z=000}; foreach (var s in l3){ Console.WriteLine(s.x + s.y + s.z); } ls[0].Name = "wxd"; foreach (var s in l3){ Console.WriteLine(s.x + s.y + s.z);}System.Console.Read();}} public class T{public string Name;public int Value;}public class T2{public string x;public int y;public int z;}

1. 如果不要延迟查询运算，而是要对它们立刻就执行运算，

   可以使用内置的ToList() 和ToArray() 运算符来返回一个包括了结果集的List或者数组。

List ls = new List() { 1, 2, 3, 4, 5 }; // var l3 = (from temp in ls select temp);var l3 = (from temp in ls select temp).ToList() ;

from in select

class Program{static void Main(string[] args){List ls = new List { new T { Name = "a", Value = 1 }, new T { Name = "b", Value = 2 }, new T { Name = "c", Value = 3 }, };List li = new List {1,2 }; var l1 = from temp1 in lsfrom temp2 in liwhere temp1.Value == temp2select new { temp1.Name, v = temp2 * 100 }; //返回一个新的匿名类的集合}} public class T{public string Name;public int Value;}

orderby 排序

orderby 字段,字段 descending /ascending

public class a{static void Main(string[] args){List ls = new List { new T { Name = "a", Value = 1 }, new T { Name = "b", Value = 2 }, new T { Name = "c", Value = 3 }, }; var l1 = (from temp in ls orderby temp.Value, temp.Name select temp); var l2 = (from temp in ls orderby temp.Value descending select temp); var l3 = (from temp in ls where temp.Value < 5 orderby temp.Value ascending select temp); var l4 = (from temp in ls orderby temp.Value ascending where temp.Value < 5 select temp);}} public class T{public string Name;public int Value;}

group by into 分组

分组结果集合 = from 临时变量A in 要查询的集合group 临时变量A by 分组关键字 into 临时变量Bselect 临时变量B 其中的 into 关键字表示 将前一个查询的结果视为后续查询的生成器，这里是跟 group by 一起使用的。
分组结果集合System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>

public class a{ static void Main(string[] args){List ls = new List { new T { Name = "a", Value = 1 }, new T { Name = "b", Value = 2 }, new T { Name = "c", Value = 3 }, new T { Name = "d", Value = 1 }, new T { Name = "e", Value = 3 } }; var l1 = from temp in lsgroup temp by temp.Value into gpselect gp; var l2 = from temp in lsorderby temp.Name descending //对ls的结果集合排序group temp by temp.Value into gporderby gp.Key descending //对组集合排序select gp; System.Collections.Generic.IEnumerable<System.Linq.IGrouping<int,T>> l3 = from temp in lsgroup temp by temp.Value into gpselect gp;foreach (var s in l2){Console.WriteLine("{0}组",s.Key);foreach (var ss in s){Console.WriteLine(ss.Name);}} }} public class T{public string Name;public int Value;}

string[] wxd = { "Java", "C#", "C++", "Delphi", "VB.net", "VC.net", "C++ Builder", "Kylix", "Perl", "Python" }; var query = from item in wxdorderby itemgroup item by item.Length into lengthGroupsorderby lengthGroups.Key descendingselect lengthGroups; foreach (var item in query){Console.WriteLine("长度 {0}", item.Key);foreach (var val in item){Console.WriteLine(val);}}

join in on equals 联合查询

public class a{ static void Main(string[] args){List ls1 = new List { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };List ls2 = new List { new T2 { ID = "a", bak = "hello" }, new T2 { ID = "a", bak = "wxwinter" }, new T2 { ID = "c", bak = "lzm" }, }; //返回一个新的匿名类的集合var li = from temp1 in ls1 join temp2 in ls2 on temp1.Name equals temp2.ID select new { temp1.Name, temp1.Value, temp2.ID, temp2.bak };foreach (var s in li){Console.WriteLine("{0}-{1}-{2}-{3}",s.Name,s.ID,s.Value,s.bak);}}} public class T1{public string Name;public int Value;}public class T2{public string ID;public string bak;}

into 汇总

static void Main(string[] args){List ls1 = new List { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };List ls2 = new List { new T2 { ID = "a", bak = "hello" }, new T2 { ID = "a", bak = "wxwinter" }, new T2 { ID = "c", bak = "lzm" }, }; //返回一个新的匿名类的集合var li = from temp1 in ls1join temp2 in ls2 on temp1.Name equals temp2.IDinto newtabselect new { temp1.Name, temp1.Value, 个数 = newtab.Count() };foreach (var s in li){Console.WriteLine("Name :{0},共有:{1}",s.Name,s.个数.ToString());}}} public class T1{public string Name;public int Value;}public class T2{public string ID;public string bak;}

DataSource 数据绑定

public class aa{public string a{ get; set; } public string b{ get; set; }}

winformList ls = new List { new aa { a = "a", b = "1" }, new aa { a = "b", b = "2" } }; dataGridView1.DataSource = ls; //数据修改会与集合同步//两个控件指针会同步comboBox1.DataSource = ls;comboBox1.DisplayMember = "b";
aspnetprotected void Button1_Click(object sender, EventArgs e){List ls = new List { new aa { a = "a", b = "1" }, new aa { a = "b", b = "2" } };this.GridView1.DataSource = ls; DropDownList1.DataSource = ls;DropDownList1.DataTextField = "b";DropDownList1.DataValueField = "a";this.DataBind();}