zoukankan html css js c++ java

Linq笔记

LINQ查询结果集
System.Array 数组
System.Collections 集合
System.Linq
接口
集合扩展方法
Lambda表达式
QuerySyntax 查询语法
DataSource 数据绑定

LINQ查询结果集

Linq	System.Collections.Generic.IEnumerable
Linq to DataSet	System.Data.EnumerableRowCollection
Linq to SQL	System.Linq.IQueryable
Linq to XML	System.Collections.Generic.IEnumerable

System.Array 数组

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

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

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

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

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

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

基于System.Array定义数组

System.Array x=System.Array.CreateInstance(typeof(string),7);x.SetValue("4",0);x.SetValue("8",1);x.SetValue("7",2);x.SetValue("1",3);x.SetValue("3",4);x.SetValue("2",5);x.SetValue("5",6);System.Console.WriteLine(x.GetValue(5));
使用这种方式声明，只能用SetValue与GetValue方法进行赋值与取值，不能使用x[i]的方式，也不会有x[i].方法() 出现

基于类型定义数组

类型[,] 数组名 = new 类型[该维个数, 该维个数];
类型[,] 数组名;数组名 = new 类型[个数,个数];
类型[,] 数组名;数组名 = new 类型[,] {{{值1, 值2, 值3},{值1, 值2, 值3}};
类型[,] 数组名 = {{值1, 值2, 值3},{值1, 值2, 值3}};类型[] 数组名 ={{值1, 值2, 值3};

数组元素的清空

数组名 = null;
这时不只数组中的元素数据被清空了,而且数组的元素也被清空了.如果要再使用该数组,需要用重新指定维中的元素个数.数组的维结构不能被清除.

System.Array类静态成员

清空指定数组位置中元素的值	Array.Clear(数组名, 从第几个开始, 清除几个)
把[源数组名]中的数据复制到[目标数组名]	Array.Copy(源数组名, 目标数组名, 要复制的个数)
按升序排列.只能对一维数组使用	Array.Sort(数组名)
对数组中的元素的顺序返转.	Array.Reverse(数组名)
从前向后在数组中查找指定的值.反回在数组中的位置值,如果没找到返回-1,第一个位置是0.	i= Array.IndexOf (数组名,要找的内容,开始位置)
从后向前在数组中查找指定的值.反回在数组中的位置值,如果没找到返回-1,第一个位置是0.	i = Array.LastIndexOf (数组名,要找的内容,开始位置)

不用循环填充数组

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

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

数组类实例成员

属性	Rank	返回数组的维数
属性	Length	返回数组中元素的个数.
方法	GetLength(维数)	返回指定维数中元素的个数.第一维是0

扩展方法见集合扩展方法

System.Collections 集合

ArrayList

System.Collections

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

实例成员

Capacity属性	获取或设置 ArrayList 可包含的元素数.当实际元素超过Capacity属性时，Capacity属性会在原来的数值上翻倍
Count属性	集合中元素的个数
int = Add(object)	将对象添加到集合尾部
AddRange（Array/List）	将 ICollection 的元素添加到 ArrayList 的末尾
object = Clone()	创建 ArrayList 的浅表副本
ArrayList =GetRange (index, count)	源 ArrayList 中元素的子集.可以看成一个视图，两个集合数据是同步的
Insert(i,object)	将对象插入到集合的指定位置
InsertRange (index,Array/List)	将 ICollection 的元素插入到 ArrayList 的指定索引处
Remove(object)	从集合中移除指定对象
RemoveAt(index)	从集合中移除指定位置处的对象
RemoveRange (index,count)	从 ArrayList 中移除一定范围的元素
SetRange (index,Array/List)	将参数中的集合覆盖到调用该方法的集合的指定位置
Reverse()	返转集合中的对象
Sort()	对集合排序对象集合见 System.IComparable接口Sort (IComparer) 方法见 System.Collections.IComparer 接口
Clear()	清除集合中所有元素
向后查找	Integer=集合名.IndexOf (要找的内容变量,开始找的位置)从前向后在数组中查找指定的值.反回在数组中的位置值,如果没找到返回-1,第一个位置是0.
向前查找	Integer =集合名. LastIndexOf(要找的内容变量,开始位置)从后向前在数组中查找.反回在数组中的位置值,如果没找到返回-1
访问集合中的成员	集合[index]

静态成员

ArrayList ls2 = ArrayList.FixedSize(ls1)	ls2的元素允许修改，但不允许添加或移除。两个集合数据是同步的
ArrayList ls2 = ArrayList. ReadOnly(ls1)	ls2的元素只读。两个集合数据是同步的

List

System.Collections.Generic

System.Collections.Generic.List<System.Windows.Forms.TextBox> jh = new List();jh.Add(new TextBox());jh.Add(new TextBox());jh.Add(new TextBox());int i = 100; foreach (System.Windows.Forms.TextBox tp in jh){i = i + 100;tp.Text =i.ToString();tp.Left = i;this.Controls.Add(tp);}
class a{public a(string v){ s = v;}public string s;}//使用System.Collections.Generic.List jh = new List ();jh.Add(new a("123"));jh.Add(new a("456"));jh.Add(new a("789")); foreach (a tp in jh){System.Console.WriteLine(tp.s);}

除ArrayList方法外

ConvertAll

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

创建复本

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

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

标准委托	public static void Main(){List ls = new List() { "1", "2", "3" }; //System.Converter<string, int> cw=new Converter<string,int>(stringToint);//List li = ls.ConvertAll(cw); List li= ls.ConvertAll(stringToint); }public static int stringToint(string s){return int.Parse(s);}
匿名方法	List ls = new List() { "1", "2", "3" };List li = ls.ConvertAll(delegate(string s) { return int.Parse(s); });
Lambda表达式	List ls = new List() { "1", "2", "3" };List li = ls.ConvertAll(i=>int.Parse(i));
集合扩展方法	List ls = new List() { "1", "2", "3" };// System.Collections.Generic.IEnumerable li = ls.Select(i => int.Parse(i)); ;var li = ls.Select(i=>int.Parse(i));

将当前 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)对传递给它的对象执行某个操作的方法的委托

标准委托	static void Main(string[] args){List ls = new List{"wxd","lzm"}; // System.Action w = new System.Action(wxdPrint);// ls.ForEach(w); ls.ForEach(wxdPrint); } static void wxdPrint(string s){Console.WriteLine(s);}
匿名方法	List ls = new List{"wxd","lzm"};ls.ForEach(delegate(string name){ Console.WriteLine(name); });
Lambda表达式	List ls = new List { "wxd", "lzm" };ls.ForEach(v=> Console.WriteLine(v));
集合扩展方法

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);定义一组条件并确定指定对象是否符合这些条件的方法

标准委托	public static void Main(){List ls = new List() { 1, 2, 3 }; //System.Predicate cw = new Predicate(wxdFind);// int a = ls.Find(cw); int a = ls.Find(wxdFind);}public static bool wxdFind(int v){bool b = (v >= 2);// 查找条件return b;}
匿名方法	List ls = new List() { 1, 2, 3 };int a = ls.Find(delegate(int v) { bool b = (v <= 2); return b; });
Lambda表达式	List ls = new List() { 1, 2, 3 };int a = ls.Find(v => v >= 2);

FindAll

public List FindAll (Predicate match)

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

创建复本

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

标准委托	public static void Main(){List ls = new List() { 1, 2, 3 }; // System.Predicate cw = new Predicate(WxdFind);//List li = ls.FindAll(cw); List li = ls.FindAll(WxdFind);}public static bool WxdFind(int v){bool b = (v <= 2);// 查找条件return b;}
匿名方法	List ls = new List() { 1, 2, 3 };List li = ls.FindAll(delegate(int v) { bool b = (v <= 2);return b; });
Lambda表达式	List ls = new List() { 1, 2, 3 };List li = ls.FindAll(v => v <= 2);
集合扩展方法	//以视图形式，不创建复本List ls = new List() { 1, 2, 3 ,4,5};//System.Collections.Generic.IEnumerable li = ls.Where(i => i < 3);var li = ls.Where(i => i < 3);

RemoveAll

public int RemoveAll (Predicate match)

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

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

标准委托	static void Main(string[] args){List ls = new List() { 1,2, 2, 3,4,5 }; //System.Predicate cw = new Predicate(WxdRem);//int n = ls.RemoveAll(cw); int n = ls.RemoveAll(WxdRem); //n为移除的个数} public static bool WxdRem(int v){bool b = (v <= 2);// 条件return b;}
匿名方法	List ls = new List() { 1,2, 2, 3,4,5 };int n = ls.RemoveAll(delegate(int v) { bool b = (v <= 2);return b; });
Lambda表达式	List ls = new List() { 1, 2, 3 };ls.RemoveAll(v => v<=2 );

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的正数

标准委托	static void Main(string[] args){List ls = new List{1,3,2,4,5,0,8,1}; // System.Comparison w = new Comparison(wxdSort);// ls.Sort(w); ls.Sort(wxdSort);} static int wxdSort(int x,int y){int v = x - y;return v;//return -v; //升序}
匿名方法	List ls = new List{1,3,2,4,5,0,8,1};ls.Sort(delegate(int x, int y) { return x - y; });
Lambda表达式	List ls = new List { 1, 3, 2, 4, 5, 0, 8, 1 };ls.Sort((x, y) => y - x);
集合扩展方法	//以视图形式，不创建复本//不改变原集合的顺序List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };//System.Collections.Generic.IEnumerable li = ls.OrderBy(i => i);var li = ls.OrderBy(i => i);

Hashtable

System.Collections

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

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

哈希表使用的是链式存储

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

哈希表中，键名不能重复

添加键对	实例.Add(键,值);
查找值	bool = 实例.ContainsValue(值)
查找键	bool = 实例.ContainsKey(键)
移除键对	实例.Remove(键)
清空集合	实例..Clear()
通过键访问值	x[键]
得到所有键集合	foreach(object t1 in x.Keys){System.Console.WriteLine(t1);}
得到所有值集合	foreach(object t2 in x.Values){System.Console.WriteLine(t2);}
得到所有键值对集合	foreach(object zd in x){ System.Collections.DictionaryEntry obj =(DictionaryEntry)zd;System.Console.WriteLine(obj.Key);System.Console.WriteLine(obj.Value);}

SortedList

System.Collections

SortedList将ArrayList与Hashtable的功能集成

集合容量	实例.Capacity 属性
查找键	bool = 实例.ContainsKey(键)
查找值	bool = 实例.ContainsValue(值)
得到索引处值	object =实例.GetByIndex(index)
设置索引处值	实例.SetByIndex(3,值)
通过键访问值	实例[键]
移除键对	实例.Remove(键)
移除索引处键对	实例.RemoveAt(index)
得到所有值集合
得到所有键值对集合
得到所有键值对集合

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

HashSet

System.Collections.Generic

提供高性能的集运算。集是一组不重复出现且无特定顺序的元素

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

正常使用

定义:public class 集合 : System.Collections.CollectionBase, System.Collections.IEnumerable{//属性访问器成员 this[int index]{get{ return (成员)List[index] ; }} //添加成员public int Add(成员 v){ return List.Add(v);} //实现GetEnumerator接口public new System.Collections.IEnumerator GetEnumerator(){迭代器 d = new 迭代器(this);return d;}//--------以下为迭代器类-------------//迭代器子类public class 迭代器 : System.Collections.IEnumerator{int index = -1; //索引用集合 jh; public 迭代器(集合 v) //构造函数{ jh = v; } public void Reset() //重新初始化索引{index = -1;} public object Current //返回当前索引所指的对象{get{return jh.List[index];}} public bool MoveNext() //将索引指针向下移动一位{if (index < jh.List.Count-1){index = index + 1;return true;}return false;}}//--------以下为成员类-------------//迭代器中的数据成员public class 成员{ public string a;}}
使用集合.成员 s1 = new 集合.成员();集合.成员 s2 = new 集合.成员();s1.a = "wxd";s2.a = "lzm"; 集合 j = new 集合(); j.Add(s1);j.Add(s2); //第一种方法：显示使用System.Collections.IEnumerator ee = j.GetEnumerator();while (ee.MoveNext()){集合.成员 temp = ( 集合.成员)ee.Current;System.Console.WriteLine(temp.a );} //第二种方法：隐式使用foreach (集合.成员 bb in j){System.Console.WriteLine(bb.a);}

定义:public class 集合 : System.Collections.CollectionBase, System.Collections.IEnumerable{//属性访问器成员 this[int index]{get{ return (成员)List[index] ; }} //添加成员public int Add(成员 v){ return List.Add(v);} //实现GetEnumerator接口public new System.Collections.IEnumerator GetEnumerator(){迭代器 d = new 迭代器(this);return d;}//--------以下为迭代器类-------------//迭代器子类public class 迭代器 : System.Collections.IEnumerator{int index = -1; //索引用集合 jh; public 迭代器(集合 v) //构造函数{ jh = v; } public void Reset() //重新初始化索引{index = -1;} public object Current //返回当前索引所指的对象{get{return jh.List[index];}} public bool MoveNext() //将索引指针向下移动一位{if (index < jh.List.Count-1){index = index + 1;return true;}return false;}}//--------以下为成员类-------------//迭代器中的数据成员public class 成员{ public string a;}}

使用集合.成员 s1 = new 集合.成员();集合.成员 s2 = new 集合.成员();s1.a = "wxd";s2.a = "lzm"; 集合 j = new 集合(); j.Add(s1);j.Add(s2); //第一种方法：显示使用System.Collections.IEnumerator ee = j.GetEnumerator();while (ee.MoveNext()){集合.成员 temp = ( 集合.成员)ee.Current;System.Console.WriteLine(temp.a );} //第二种方法：隐式使用foreach (集合.成员 bb in j){System.Console.WriteLine(bb.a);}

C#的 yield

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

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

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

创建public class wxd : System.Collections.IEnumerable{string[] v = { "a", "b", "c", "d", "e", "f", "g" }; public System.Collections.IEnumerator GetEnumerator(){for (int i = 0; i < v.Length; i++){yield return v[i];}yield return "wxd";yield return "lzm";}}
使用wxd x = new wxd(); //第一种方法：显示使用System.Collections.IEnumerator ee = x.GetEnumerator();while (ee.MoveNext()){string temp = (string)ee.Current;System.Console.WriteLine(temp);} //第二种方法：隐式使用foreach (string v in x){System.Console.WriteLine(v);}
结果abcdefgwxdlzm

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.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;}}}}

延迟类

1．须引用System.Core

2．对所有的集合者适用

3．最好用var对象存值

4．可以连用

var li = ls.OrderBy(i => i).Take(5);表示排序后的前5个

5．使用System.Func委托

System.FuncSystem.Func<T,TResult>System.Func<T1,T2,TResult>System.Func<T1,T2,T3,TResult>System.Func<T1,T2,T3,T4,TResult>

6.只是视图，不创建复本

Select 选择

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

Lambda表达式	List ls = new List() { "1", "2", "3" };// System.Collections.Generic.IEnumerable li = ls.Select(i => int.Parse(i)); ;var li = ls.Select(i=>int.Parse(i));
标准委托	static void Main(string[] args){List ls = new List() { "1", "2", "3" };var li = ls.Select<string,string>(stringAdd);} public static string stringAdd(string s){return s+"wxd";}
匿名方法	List ls = new List() { "1", "2", "3" };var li = ls.Select<string, int>(delegate(string s) { return int.Parse(s); });
Linq同类功能	List ls = new List() { "1", "2", "3" };var li = from temp in ls select temp;

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

Lambda表达式	//以视图形式，不创建复本List ls = new List() { 1, 2, 3 ,4,5};//System.Collections.Generic.IEnumerable li = ls.Where(i => i < 3);var li = ls.Where(i => i < 3);
标准委托	static void Main(string[] args){List ls = new List() { 1, 2, 3, 4, 5 };// System.Func<int, bool> ww = new Func<int, bool>(w);// var li = ls.Where(ww);var li = ls.Where(w);} public static bool w(int v){return v<3;}
匿名方法	List ls = new List() { 1, 2, 3, 4, 5 }; var li = ls.Where(delegate(int v){return v<3;});
Linq同类功能	List ls = new List() { 1, 2, 3, 4, 5 };var li = from temp in ls where temp< 3 select temp;

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中的顺序已重新排列

Lambda表达式	//以视图形式，不创建复本//不改变原集合的顺序List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };//System.Collections.Generic.IEnumerable li = ls.OrderBy(i => i);var li = ls.OrderBy(i => i);
标准委托	static void Main(string[] args){List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = ls.OrderBy<int,int >(w );} public static int w(int i){return -i; //降序}
匿名方法	List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };//var li = ls.OrderBy<int, int>(delegate(int i) { return -i; });var li = ls.OrderBy(delegate(int i) { return -i; })
Linq同类功能	List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = from temp in ls orderby temp select temp;

OrderByDescending 排序降

匿名方法	List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = ls.OrderByDescending(delegate(int i) { return i; });
Lambda表达式	List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = ls.OrderByDescending(i => i);
OrderBy模拟	List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = ls.OrderBy(delegate(int i) { return -i; });
Linq同类功能	List ls = new List() { 1, 3, 2, 4, 5, 0, 8, 1 };var li = from temp in ls orderby temp descending select temp;

GroupBy 分组

该方法分组结果集合

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

Lambda表达式	string[] wxd = { "Java", "C#", "C++", "Delphi", "VB.net", "VC.net", "C++ Builder", "Kylix", "Perl", "Python" }; var query = wxd.GroupBy(p => p.Length); foreach (var item in query){Console.WriteLine("长度 {0}", item.Key);foreach (var val in item){Console.WriteLine(val);}}
Linq同类功能	string[] wxd = { "Java", "C#", "C++", "Delphi", "VB.net", "VC.net", "C++ Builder", "Kylix", "Perl", "Python" }; var query = from item in wxdgroup item by item.Length into lengthGroupsselect lengthGroups;

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

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

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

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集合平均值求和

List ls3 = new List() { 1, 3, 2, 2, 5, 2, 8, 2 }; var b1 = ls3.Average(); //3.125 var b2 = ls3.Sum(); //25
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 } }; var b1 = ls1.Average(p=>p.Value); //2.33333333333333 var b2 = ls1.Sum(p=>p.Value); //7}} public class T1{public string Name;public int Value;}

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

List ls3 = new List() { 1, 3, 2, 2, 5, 2, 8, 2 }; var b1 = ls3.Min(); //1 var b2 = ls3.Max(); //8
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 } }; var b1 = ls1.Min(p=>p.Value); //1 var b2 = ls1.Max(p=>p.Value); //4}} public class T1{public string Name;public int Value;}

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

List ls3 = new List() { 1, 2, 3, 4, 5, 6, 7, 8, 9,10 }; var b1 = ls3.Aggregate((x, y) => x + y );//55 累加var b2 = ls3.Aggregate((x, y) => x * y);//3628800 累乘
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 } }; var b3 = ls1.Aggregate((x, y) => new T1 { Value = x.Value + y.Value }); System.Console.WriteLine(b3.Value); //7 }} public class T1{public string Name;public int Value;}

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集合,浅复本

List ls3 = new List() { "wxd","lzm","wxwinter" ,"wxd"}; List ss = ls3.ToList(); ls3[0] = "kk"; //不影响 ss 集合
List ls3 = new List() { "wxd","lzm","wxwinter" ,"wxd"}; var ss = ls3.Select(p=>p); ls3[0] = "kk"; //影响 ss 集合

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表达式是委托的一种实现方式。与匿名方法类似。

格式

声名参数=> 分隔符表达式表达式的结果为委托返回值
p => p + 1p => p < 4(int p) => p +1(p1,p2) => p1 + p2

例1(比效)

Lambda表达式	public delegate TR lzm<T, TR>(T v1); class a{public void f(lzm<int, bool> func){bool b= func(100);if (b){System.Console.WriteLine("v大于100");}else{System.Console.WriteLine("v小于100");}}} class Program{static void Main(string[] args){a obj = new a();int v = 70;obj.f(p => v > p);obj.f((int p) => v > p); //显示类型}}
委托	public delegate TR lzm<T, TR>(T v1); class a{public void f(lzm<int, bool> func){bool b= func(100);if (b){System.Console.WriteLine("v大于100");}else{System.Console.WriteLine("v小于100");}}} class Program{static void Main(string[] args){a obj = new a();obj.f(w);} public static bool w(int v1){int v = 70;bool b = v > v1; return b;} }
匿名方法	public delegate TR lzm<T, TR>(T v1); class a{public void f(lzm<int, bool> func){bool b= func(100);if (b){System.Console.WriteLine("v大于100");}else{System.Console.WriteLine("v小于100");}}} class Program{static void Main(string[] args){a obj = new a();obj.f( delegate(int v1) {return 70 > v1; });Console.Read();}}

例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）

Lambda表达式中Lifting

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的值即可。因为编译器会对该临时变量重新分配内存，这样，每次循环，都重新分配新的内存，就不会有这个问题

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 查询语法

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

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

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

查询句法返回的类型是 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;}

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

可以使用内置的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);}}

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

查看全文

相关阅读:
[BZOJ 1001] [BeiJing2006]狼抓兔子
 [BZOJ 1070] [SCOI2007] 修车
 [BZOJ 1834] [ZJOI2010]network 网络扩容
 [POJ 2135] Farm Tour
[CodeFights] Changu Circle
[Noip模拟赛] Power
[Noip模拟赛] Polygon
【学习】计算几何初步
 【学习】序列DP
[BZOJ 2659] [Beijing wc2012] 算不出的算式

原文地址：https://www.cnblogs.com/qzdd/p/13036299.html