Linq	System.Collections.Generic.IEnumerable<T>
Linq to DataSet	System.Data.EnumerableRowCollection<DataRow>
Linq to SQL	System.Linq.IQueryable<T>
Linq to XML	System.Collections.Generic.IEnumerable<T>

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<T>

System.Collections.Generic

System.Collections.Generic.List<System.Windows.Forms.TextBox> jh = new List<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<a> jh = new List<a>();

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<TOutput> ConvertAll<TOutput> (Converter<T,TOutput> converter)

创建复本

调用委托

System.Converter< TInput,TOutput>

public delegate TOutput Converter<TInput, TOutput>(TInput input);

将对象从一种类型转换为另一种类型的方法

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

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

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

static void Main(string[] args)

{

List<string> ls = new List<string>() { "1", "2", "3" };

List<string> li = ls.ConvertAll<string >(stringAdd);

}

public static string stringAdd(string s)

{

return s+"wxd";

}

ForEach

public void ForEach ( Action<T> action)

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

调用委托

System.Action <T>

public delegate void Action<T> (T obj)

对传递给它的对象执行某个操作的方法的委托

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

Find、FindLast、FindIndex、FindLastIndex、Exists、TrueForAll

public T Find (Predicate<T> match)

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

创建复本

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

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

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

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

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

调用委托

System.Predicate<T>

public delegate bool Predicate<T>(T obj);

定义一组条件并确定指定对象是否符合这些条件的方法

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

FindAll

public List<T> FindAll (Predicate<T> match)

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

创建复本

调用委托

System.Predicate<T>

public delegate bool Predicate<T>(T obj);

定义一组条件并确定指定对象是否符合这些条件的方法

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

RemoveAll

public int RemoveAll (Predicate<T> match)

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

调用委托

System.Predicate<T>

public delegate bool Predicate<T>(T obj);

定义一组条件并确定指定对象是否符合这些条件的方法

标准委托	static void Main(string[] args) { List<int> ls = new List<int>() { 1,2, 2, 3,4,5 }; //System.Predicate<int> cw = new Predicate<int>(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<int> ls = new List<int>() { 1,2, 2, 3,4,5 }; int n = ls.RemoveAll(delegate(int v) { bool b = (v <= 2);return b; });
Lambda表达式	List<int> ls = new List<int>() { 1, 2, 3 }; ls.RemoveAll(v => v<=2 );

Sort

public void Sort ( Comparison<T> comparison)

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

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

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

调用委托

System.Comparison<T>

public delegate int Comparison<T> (T x,T y)

表示比较同一类型的两个对象的方法

x 小于 y 返回小于0的负数

x 等于 y 返回0

x 大于 y 返回大于0的正数

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

public 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<T>

System.Collections.Generic

class a

{

public a(string v)

{

s = v;

}

public string s;

}

//使用

System.Collections.Generic.Queue<a> jh = new Queue<a>();

//入队

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<T>

System.Collections.Generic

class a

{

public a(string v)

{

s = v;

}

public string s;

}

//使用

System.Collections.Generic.Stack<a> jh = new Stack<a>();

//入栈

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<T>

System.Collections.Generic

class a

{

public a(string v)

{s = v;}

public string s;

}

//使用

System.Collections.Generic.LinkedList<a> lb = new LinkedList<a>();

System.Collections.Generic.LinkedListNode<a> p;

void 添加结点()

{

p = new LinkedListNode<a>(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<T>

System.Collections.Generic

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

System.Collections.Generic.HashSet<int> h = new HashSet<int>();

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

}

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

}

结果

零 : 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 <T>

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<wxd> ls = new List<wxd> { 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<wxd>

{

public int value;

public override int Compare(wxd x, wxd y)

{

int v = x.value - y.value;

return v;

}

System.Linq.IGrouping<T>

System.Linq.ILookup<TKey,TElement>

System.Linq.IOrderedEnumerable<T>

System.Linq.IOrderedQueryable

System.Linq.IOrderedQueryable<T>

System.Linq.IQueryable

System.Linq.IQueryable<T>

System.Linq.IQueryProvider

集合扩展方法

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

public class a

{

public int ID { get; set; }

public string Name { get; set; }

public static void Main()

{

List<a> list = new List<a> { 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<a> 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<TSource> WxdWhere<TSource>(this IEnumerable<TSource> 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.Func<TResult>

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

SelectMany 选择

Lambda表达式

List<string> ls = new List<string>() { "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<int> ls = new List<int>() { 1, 2, 3, 4, 5 };

var li = ls.Where(i => i < 3); //li中此时只有1,2

ls[0] = 333; //1已改为333，li中此时只有2

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

OrderBy 排序升

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

List<int> ls = new List<int>() { 1, 3, 2, 4, 5, 0, 8, 1 };

var li = ls.OrderBy(i => i);

//----

ls[1] = 6666;

ls.Add(-5);

//---li中的顺序已重新排列

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

OrderByDescending 排序降

匿名方法	List<int> ls = new List<int>() { 1, 3, 2, 4, 5, 0, 8, 1 }; var li = ls.OrderByDescending(delegate(int i) { return i; });
Lambda表达式	List<int> ls = new List<int>() { 1, 3, 2, 4, 5, 0, 8, 1 }; var li = ls.OrderByDescending(i => i);
OrderBy模拟	List<int> ls = new List<int>() { 1, 3, 2, 4, 5, 0, 8, 1 }; var li = ls.OrderBy(delegate(int i) { return -i; });
Linq同类功能	List<int> ls = new List<int>() { 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 wxd

group item by item.Length into lengthGroups

select lengthGroups;

Join 联合查询

Lambda表达式

static void Main(string[] args)

{

List<T1> ls1 = new List<T1> { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };

List<T2> ls2 = new List<T2> { 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<T1> ls1 = new List<T1> { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };

List<T2> ls2 = new List<T2> { 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 ls1

join temp2 in ls2 on temp1.Name equals temp2.ID

into newtab

select new { temp1.Name, temp1.Value, 个数 = newtab.Count() };

Take 获取集合的前n个元素

//以视图形式，不创建复本

List<int> ls = new List<int>() { 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<int> ls = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,50 };

var li = ls.Skip(5);

Distinct 过滤集合中的相同项

List<int> ls = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1 };

var li = ls.Distinct();

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

List<int> ls1 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1 };

List<int> ls2 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 };

var li = ls1.Union(ls2);

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

List<int> ls1 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1 };

List<int> ls2 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 };

var li = ls1.Concat(ls2);

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

List<int> ls1 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,50 };

List<int> ls2 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 };

var li = ls1.Intersect(ls2);

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

List<int> ls1 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,50 };

List<int> ls2 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,100,200,100,300 };

var li = ls1.Except(ls2);

Reverse 反转集合

List<int> ls = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,50 };

ls.Reverse();

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

List<int> ls = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1,50 };

var li =ls.TakeWhile(p=>p<4);

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

List<int> ls = new List<int>() { 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<string > ls2 = (List<string >)ls1; //编译会报错

// List<string> ls3 = (List<string>)ls1.Cast<string>(); //运行会报错

var ls4 = ls1.Cast<string >();

List<string> ls5 = ls1.Cast<string>().ToList<string>();

OfType 过滤集合中的指定类型

ArrayList ls1 = new ArrayList {"a","b","c",1 };

var ls4 = ls1.OfType<string>().Cast<string >();

ls1[0] = 345;

foreach (object s in ls4)

{

System.Console.WriteLine(s);

}

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

得到的是复本

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

List<int> ls = new List<int>() { 1, 3, 2, 2, 5, 2, 8,1 };

var o = ls.ElementAtOrDefault(100);

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

public class a

{

static void Main(string[] args)

{

List<T2> ls2 = new List<T2> { 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<T2> ls2 = new List<T2> { 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") ); //true

bool 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<T2> ls2 = new List<T2> { 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") );//false

bool b2 = ls2.All(p => p.ID.Length ==1 ); //true

}

public class T2

{

public string ID;

public string bak;

}

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

List<int> ls1 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1 };

List<int> ls2 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1 };

bool b1 = ls2.SequenceEqual(ls1); //true

Count 、LongCount集合中的元素个数

List<int> ls2 = new List<int>() { 1, 3, 2, 2, 5, 2, 8, 1 };

int b1 = ls2.Count(p => p < 3); //5

int b2 = ls2.Count(); //8

Average 、Sum集合平均值求和

List<int> ls3 = new List<int>() { 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<T1> ls1 = new List<T1> { 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<int> ls3 = new List<int>() { 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<T1> ls1 = new List<T1> { 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<int> ls3 = new List<int>() { 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<T1> ls1 = new List<T1> { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 4 } };

var b3 = ls1.Aggregate<T1>((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<string > ls3 = new List<string >() { "wxd","lzm","wxwinter" ,"wxd"};

var ls4 = ls3.Where(p => p == "ok").DefaultIfEmpty("not"); ;

//如果不存在返回给集合一个自定义的对象

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

List<string > ls3 = new List<string >() { "wxd","lzm","wxwinter" ,"wxd"};

string[] ss = ls3.ToArray();

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

List<string > ls3 = new List<string >() { "wxd","lzm","wxwinter" ,"wxd"};

List<string> ss = ls3.ToList();

ls3[0] = "kk"; //不影响 ss 集合

List<string > ls3 = new List<string >() { "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<T1> ls1 = new List<T1> { 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 + 1

p => 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）

public class a

{

public int ID { get; set; }

public string Name { get; set; }

public static void Main()

{

List<a> list = new List<a> { 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<a> 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<TSource> WxdWhere<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)

{

foreach (TSource item in source)

{

if (predicate(item))

{

yield return item;

}

Lambda表达式中Lifting

public class a

{ static void Main(string[] args)

{

List<Func<int>> list = new List<Func<int>>();

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<T>

public class a

{

static void Main(string[] args)

{

List<T> ls = new List<T> { 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<T> 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<T> ls = new List<T> { 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<T>或者数组。

List<int> ls = new List<int>() { 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<T> ls = new List<T> { new T { Name = "a", Value = 1 }, new T { Name = "b", Value = 2 }, new T { Name = "c", Value = 3 }, };

List<int> li = new List<int> {1,2 };

var l1 = from temp1 in ls

from temp2 in li

where temp1.Value == temp2

select 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<T> ls = new List<T> { 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 临时变量B

select 临时变量B

其中的 into 关键字表示将前一个查询的结果视为后续查询的生成器，这里是跟 group by 一起使用的。

分组结果集合

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

public class a

{

static void Main(string[] args)

{

List<T> ls = new List<T> { 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 ls

group temp by temp.Value into gp

select gp;

var l2 = from temp in ls

orderby temp.Name descending //对ls的结果集合排序

group temp by temp.Value into gp

orderby gp.Key descending //对组集合排序

select gp;

System.Collections.Generic.IEnumerable<System.Linq.IGrouping<int,T>> l3 = from temp in ls

group temp by temp.Value into gp

select 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 wxd

orderby item

group item by item.Length into lengthGroups

orderby lengthGroups.Key descending

select 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<T1> ls1 = new List<T1> { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };

List<T2> ls2 = new List<T2> { 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<T1> ls1 = new List<T1> { new T1 { Name = "a", Value = 1 }, new T1 { Name = "b", Value = 2 }, new T1 { Name = "c", Value = 3 } };

List<T2> ls2 = new List<T2> { 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

into newtab

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

}

winform

List<aa> ls = new List<aa> { new aa { a = "a", b = "1" }, new aa { a = "b", b = "2" } };

dataGridView1.DataSource = ls; //数据修改会与集合同步

//两个控件指针会同步

comboBox1.DataSource = ls;

comboBox1.DisplayMember = "b";

aspnet

protected void Button1_Click(object sender, EventArgs e)

{

List<aa> ls = new List<aa> { 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();

}

查看全文

相关阅读:
熟悉中的应用与调整
 跨域
 Office办公软件操作技巧 office快捷键大全
 ROS入门介绍
 ROS开发指令
 ROS中msg和srv文件的区别
 package.xml使用说明
 Python的内置数据结构
 Python异常处理
 工作后的第二个任务（项目）

原文地址：https://www.cnblogs.com/Yjianyong/p/1825051.html

热门文章
SAP常用T-CODE
事务的一致性
 SAP角色创建与权限分配
 HIVE 函数
 linux常用命令
 Nginx配置详解
 MQ
Sping-mongodb
Linux系统常用命令
 spring