现在的位置: 首页 > 综合 > 正文

Linq、 集合、数组、Lambda、QuerySyntax

2013年08月30日 ⁄ 综合 ⁄ 共 5005字 ⁄ 字号 评论关闭

目录

1    LINQ查询结果集    1  

2    System.Array 数组    1

2.1    基于System.Array定义数组    1

2.2    基于类型定义数组    1

2.3    数组元素的清空    1

2.4    System.Array类静态成员    1

2.5    不用循环填充数组    1

2.6    数组类实例成员    2

3    System.Collections 集合    2

3.1    ArrayList    2

3.1.1    实例成员    2

2    静态成员    2

3.2    List<T>    3

3.3    Hashtable    6

3.4    SortedList    6

3.5    SortedList<TKey,TValue>    7

3.6    Queue<T>    8

3.7    Stack<T>    8

3.8    LinkedList<T>    8

3.9    HashSet<T>    9

4    System.Linq    10

4.1    System.Linq.Enumerable    10

4.2    System.Linq.Queryable    10

4.3    System.Linq.Lookup <TKey,TElement>    10

4.4    System.Linq.Expressions.Expression    10

5    接口    10

5.1    IEnumerable 、IEnumerator    10

5.1.1    正常使用    10

5.1.2    C#的 yield    12

5.2    IEnumerable <T>    12

5.3    IEnumerator <T>    12

5.4    ICollection    12

5.5    ICollection <T>    13

5.6    IList    13

5.7    IList <T>    13

5.8    IEqualityComparer    13

5.9    IEqualityComparer <T>    13

5.10    IDictionary    13

5.11    IDictionary <TKey,TValue>    13

5.12    IDictionaryEnumerator    13

5.13    IComparer    13

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

5.13.2    ArrayList.Sort (IComparer) 方法    13

5.14    IComparer <T>    14

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

5.14.2    List.Sort (IComparer) 方法    14

5.15    System.Linq.IGrouping<T>    14

5.16    System.Linq.ILookup<TKey,TElement>    14

5.17    System.Linq.IOrderedEnumerable<T>    14

5.18    System.Linq.IOrderedQueryable    14

5.19    System.Linq.IOrderedQueryable<T>    15

5.20    System.Linq.IQueryable    15

5.21    System.Linq.IQueryable<T>    15

5.22    System.Linq.IQueryProvider    15

6    集合扩展方法    15

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

6.2    延迟类    15

6.2.1    Select 选择    16

6.2.2    SelectMany 选择    16

6.2.3    Where 条件    16

6.2.4    OrderBy 排序升    17

6.2.5    OrderByDescending 排序降    17

6.2.6    GroupBy 分组    17

6.2.7    Join 联合查询    18

6.2.8    GroupJoin    18

6.2.9    Take 获取集合的前n个元素    19

6.2.10    Skip 跳过集合的前n个元素    19

6.2.11    Distinct 过滤集合中的相同项    19

6.2.12    Union 连接不同集合,自动过滤相同项    19

6.2.13    Concat 连接不同集合,不会自动过滤相同项    19

6.2.14    Intersect 获取不同集合的相同项(交集)    20

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

6.2.16    Reverse 反转集合    20

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

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

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

6.2.20    OfType 过滤集合中的指定类型    21

6.3    不延迟(浅复本)    21

6.3.1    Single 集合中符合条件的唯一元素,浅复本    21

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

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

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

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

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

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

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

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

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

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

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

6.3.13    Count 、LongCount集合中的元素个数    23

6.3.14    Average 、Sum集合平均值求和    23

6.3.15    Max、Min 集合最大值,最小值    24

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

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

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

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

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

 

7    Lambda表达式    25

7.1    例1(比效)    25

7.2    例2(多参)    27

7.3    例3(list.Where)    27

7.4    Lambda表达式中Lifting    28

8    QuerySyntax 查询语法    29

8.1    from in select    30

8.2    orderby 排序    30

8.3    group by into 分组    31

8.4    join in on equals 联合查询    33

8.5    into 汇总    33

9    DataSource 数据绑定    34

 

 

 

 

 

 

LINQ查询结果集

 

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(维数)

返回指定维数中

抱歉!评论已关闭.