LINQ to Objects(用于集合、文件、字符串对象的LINQ)

LINQ to  Object是LINQ的基础，而LINQ to SQL、LINQ to  XML是中间LINQ提供程序，它们主要把数据源转换成LINQ to Objects兼容的类型，以便与LINQ to Objects进行操作。LINQ to Objcets就是直接 对IEnumerable或IEnumberable<T>集合使用LINQ查询。

 

LINQ标准查询运算符概述

LINQ标准查询运算符是依靠一组扩展方法来实现的。而这些扩展方法分别是System.Linq.Enumerable和System.Linq.Querable这两个静态类中定义，它们是泛型IEnumerable<T>接口和泛型 IQueryable<T>接口的实现类型。

LINQ不仅能查询 实现泛型IEnumerable<T>接口或泛型 IQueryable<T>接口的类型，也能查询 实现IEnumerable接口的类型。

这是因为,在Enumerable静态 类中，定义了两个方法，即Cast<TResul>(IEnumerable)和OfType<TRsult>(IEnumerable),它们把IEnumerable接口类型转换成了泛型IEnumerable<T>接口类型。Queryable类中也有类似这样的方法。

Enumerable的扩展方法用来操作内存对象，采用线程流程 ，即每个运算符会被按顺序执行。这种执行方法如果操作类似关系型数据库的数据源，效率会非常地下，所以Queryable类型重新定义了这些扩展方法，把LINQ表达式拆解为表达式目录树，提供程序就可以根据表达式目录生成树 生成关系型数据库的查询语句，即SQL命令，然后进行 相关操作。

每个查询运算符的执行行为不同，大致分为立即执行和延期执行，延期执行的运算符将在枚举元素的时刻执行 。

 

Enumerable类的介绍

Enumerable类位于程序既System.Core.dll中，命名空间属于System.Linq.直接从System.Object继承，存在于版本号是3.5及以上的.NET框架中。

Enumerable类是静态类 ，不能实例化 和被继承，成员只有一组静态和扩展方法。

下面将按照延期执行和立即 执行这两种分类进行讲解》

一用于延期执行 的Enumerable类方法成员

1.Take方法

Take方法用于 从一个序列的开头返回指定数量的元素

DemoTake控制台应用程序，返回序列的前N个元素：

using System; using System.Linq; namespace DemoTake { class Program { static void Main(string[] args) { //定义数组 string[] nemes = { "林晚荣", "洛凝", "董巧巧", "依莲", "安碧如" }; Console.WriteLine("Take方法直接输出前3个元素"); //用Take方法直接输出前3个元素 foreach (string s in nemes.Take(3)) Console.WriteLine(s); var query = from n in nemes where n.Length == 2 select n; Console.WriteLine("/n用Take方法输出查询结果的前1个元素"); //用Take方法输出查询结果的前1个元素 foreach (string s in query.Take(1)) Console.WriteLine(s); Console.ReadKey(); } } }

2.TakeWhile方法

TakeWhile方法 用于获取序列中从开头算起复合条件的元素，知道遇到不符合条件 的元素为止

DemoTakeWhile1的控制台应用程序，返回序列中 符合条件 的元素：

using System; using System.Linq; namespace DemoTakeWhile1 { class Program { static void Main(string[] args) { //定义数组 string[] nemes = { "依莲", "董巧巧","洛凝", "安碧如" }; var takenames = nemes.TakeWhile(n => n.Length == 2); //输出字数是2个的名字 foreach (var s in takenames) Console.WriteLine(s); Console.ReadKey(); } } }

从运行结果看到，TakeWhile方法只返回1个元素，这是因为 TakeWhile检测到第2个 元素时，发现不符合条件，就 停止了输出，如果第一个元素 就不符合条件，TakeWhile则不会有任何输出，这是TakeWhile的特性。

DemoTakeWhile2控制台应用程序，返回序列中 复合 条件的元素

using System; using System.Linq; namespace DemoTakeWhile2 { class Program { static void Main(string[] args) { //定义数组 string[] nemes = { "林晚荣", "洛凝", "董巧巧","出云公主", "依莲", "安碧如" }; //返回元素字数小于4并且索引小于5的元素 var takenames = nemes.TakeWhile((n, i) => n.Length < 4 && i < 5); foreach (string s in takenames) Console.WriteLine(s); Console.ReadKey(); } } }

3.Skip方法

Skip方法用于跳过序列中指定 数量的元素，然后返回剩余的元素

DemoSkip控制台应用程序，跳过序列中的前N个元素

using System; using System.Linq; namespace DemoSkip { class Program { static void Main(string[] args) { //定义数组 string[] nemes = { "林晚荣", "洛凝", "董巧巧", "依莲", "安碧如" }; Console.WriteLine("用Skip方法跳过前3个元素后输出"); //用Skip方法跳过前3个元素后输出 foreach (string s in nemes.Skip(3)) Console.WriteLine(s); var query = from n in nemes where n.Length == 3 select n; Console.WriteLine("/n用Skip方法跳过第一个查询结果后输出"); //用Skip方法跳过第一个查询结果后输出 foreach (string s in query.Skip(1)) Console.WriteLine(s); Console.ReadKey(); } } }

4.SkipWhile方法

SkipWhile方法用于只要满足指定的条件，就跳过序列中的元素 ，然后返回剩余元素。

DemoSkipWhile1控制台应用程序跳过序列中符合条件的元素

using System; using System.Linq; namespace DemoSkipWhile1 { class Program { static void Main(string[] args) { //定义数组 string[] nemes = { "依莲", "董巧巧", "洛凝", "安碧如" }; var takenames = nemes.SkipWhile(n => n.Length == 2); //跳过字数是2个的名字后输出 foreach (var s in takenames) Console.WriteLine(s); Console.ReadKey(); } } }

 

跳过序列中复合 条件 的元素（2）

DemoSkipWhile2:

using System; using System.Linq; namespace DemoSkipWhile2 { class Program { static void Main(string[] args) { //定义数组 string[] nemes = { "林晚荣", "洛凝", "董巧巧", "出云公主", "依莲", "安碧如" }; //跳过元素字数小于4并且索引小于5的元素 var takenames = nemes.SkipWhile((n, i) => n.Length < 4 && i < 5); foreach (string s in takenames) Console.WriteLine(s); Console.ReadKey(); } } }

 

Take、TakeWhile、Skip、SkipWhile这4个方法，用于返回序列中 的部分元素，它们之间互为补充关系。这几个 方法，非常适合用于在 对查询结果 进行 分页的处理 上。

DemoPaginate控制台应用程序：

using System; using System.Linq; namespace DemoPaginate { class Program { static void Main(string[] args) { //当前页码 int ipage = 0; //每页记录数 int ipagesize = 2; //定义数组 string[] nemes = { "林晚荣", "洛凝", "董巧巧", "出云公主", "依莲", "安碧如" }; Console.WriteLine(string.Format("输出第 {0} 页记录", ipage)); //输出第 0 页记录 var q = nemes.Skip(ipagesize * ipage).Take(ipagesize); foreach (string s in q) Console.WriteLine(s); ipage++; Console.WriteLine(string.Format("/n输出第 {0} 页记录", ipage)); //输出第 1 页记录 var q2 = nemes.Skip(ipagesize * ipage).Take(ipagesize); foreach (string s in q2) Console.WriteLine(s); ipage++; Console.WriteLine(string.Format("/n输出第 {0} 页记录", ipage)); //输出第 2 页记录 var q3 = nemes.Skip(ipagesize * ipage).Take(ipagesize); foreach (string s in q3) Console.WriteLine(s); Console.ReadKey(); } } }

这个实例是对内存序列进行分页输出，数据库内容 的用LINQ分页也是这样，只是使用LINQ to SQL的类型而已。

 

6.Reverse方法

Reverse方法用于反转序列中元素的顺序

DemoReverse反向显示字符串

using System; using System.Linq; namespace DemoReverse { class Program { static void Main(string[] args) { string str = "Reverse方法，用于反转序列中元素的顺序。"; Console.WriteLine(str); Console.WriteLine("/n反转字符串/n"); var strrev = str.ToCharArray().Reverse(); foreach (var c in strrev) Console.Write(c); Console.ReadKey(); } } }

7.   Distinct方法

Distinct方法用于获取不重复的元素，也可以说是过滤掉重复的元素 ，Distinct方法的作用跟SQL语句中的Distinct关键字类似

DemoDistinct1控制台应用程序去掉序列 中重复的元素

using System; using System.Linq; namespace DemoDistinct1 { class Program { static void Main(string[] args) { ///定义一个有重复元素的数组 string[] girls = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿", "月牙儿", "秦仙儿", "洛凝", "萧玉霜"}; Console.WriteLine("含有重复元素的数组"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); var q = girls.Distinct(); Console.WriteLine("/n/n去除重复元素的序列"); foreach (var g in q) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

DemoDistinct2控制台应用程序，使用自定义比较器过滤序列中重复的元素：

在 项目中添加名称 为MyEqualityComparer类

using System.Collections.Generic; namespace DemoDistinct2 { /// <summary> /// 自定义相等比较器 /// </summary> public class MyEqualityComparer<T>: IEqualityComparer<T> { #region IEqualityComparer<T> 成员 public bool Equals(T x, T y) { string stmp = x as string; if (stmp != null) { if (stmp == "萧玉霜") return false; } if (x.GetHashCode() == y.GetHashCode()) return true; else return false; } public int GetHashCode(T obj) { return obj.GetHashCode(); } #endregion } }

只是一个 实现了泛型IEqualityComparer<TSource>接口的相等比较器。

Program.cs：

using System; using System.Linq; namespace DemoDistinct2 { class Program { static void Main(string[] args) { ///定义一个有重复元素的数组 string[] girls = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿", "月牙儿", "萧玉霜","秦仙儿", "洛凝", "萧玉霜"}; Console.WriteLine("含有重复元素的数组"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); var q = girls.Distinct(new MyEqualityComparer<string>()); Console.WriteLine("/n/n去除重复元素的序列"); foreach (var g in q) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

 

8. Union方法

Union方法用于合并两个 序列，并去掉 重复元素。

DemoUnion1控制台应用程序合并两个数组 并去掉重复元素

using System; using System.Linq; namespace DemoUnion1 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Union(girls2); Console.WriteLine("合并后的序列"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

DemoDistinct2使用自定义比较器合并两个 数组并去掉重复的元素

自定义比较器依然使用 前面DemoDistinct2实例刚建立的MyEqualityComparer比较器。

Program.cs:

using System; using System.Linq; using DemoDistinct2; namespace DemoUnion2 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Union(girls2,new MyEqualityComparer<string>()); Console.WriteLine("合并后的序列"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

 

8.Union方法

Union方法用于合并两个序列，并去掉重复 元素

DemoUnion1控制太 应用程序合并两个数组并去掉重复元素

using System; using System.Linq; namespace DemoUnion1 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Union(girls2); Console.WriteLine("合并后的序列"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

DemoDistinct2使用自定义比较器合并两个数组并去掉重复的元素

添加现有项：MyEqualityComparer.cs

Program.cs:

using System; using System.Linq; using DemoDistinct2; namespace DemoUnion2 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Union(girls2,new MyEqualityComparer<string>()); Console.WriteLine("合并后的序列"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

9.Concat方法：

Concat方法用于连接两个序列，与，Union方法不同的是不会过滤掉重复的元素

DemoConcat控制台应用程序连接两数组

using System; using System.Linq; namespace DemoConcat { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Concat(girls2); Console.WriteLine("合并后的序列"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

10.Intersect方法

Intersect方法用于生成两个序列的交集。生成交集，就是把2个序列中相同的元素提取出来，建立一个新的序列。

DemoIntersect1控制台应用程序找出2个数组中相同的元素

using System; using System.Linq; namespace DemoIntersect1 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Intersect(girls2); Console.WriteLine("在2个数组中都存在的元素序列"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

DemoDistinct2使用自定义比较器找出两个数组中相同的元素：

添加现有项：MyEqualityComparer.cs

Program.cs:

using System; using System.Linq; using DemoDistinct2; namespace DemoIntersect2 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Intersect(girls2,new MyEqualityComparer<string>()); Console.WriteLine("在2个数组中都存在的元素序列"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

11.Except方法：

Except方法用于生成两个序列的差集，生成差集，就是办两个序列中不同的元素提取出来，建立一个新的序列。

DemoExcept1找出两个数组中不同的元素

using System; using System.Linq; namespace DemoExcept1 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Except(girls2); Console.WriteLine("2个数组中不同元素"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

DemoExcept2:使用自定义比较器找出两个数组中不同的元素

添加现有项：MyEqualityComparer.cs

Program.cs

using System; using System.Linq; using DemoDistinct2; namespace DemoExcept2 { class Program { static void Main(string[] args) { ///定义数组 string[] girls1 = { "萧玉若", "洛凝", "萧玉霜", "秦仙儿" }; string[] girls2 = { "月牙儿", "秦仙儿", "洛凝", "萧玉霜" }; var girls = girls1.Except(girls2, new MyEqualityComparer<string>()); Console.WriteLine("2个数组中不同元素"); foreach (var g in girls) Console.Write(string.Format("{0} ", g)); Console.ReadKey(); } } }

12.Range方法：

Range方法用于生成指定范围的整数序列，在BS程序中，经常需要分页显示，在页面中需要显示页面号码的链接，用这个方法可以生成页码数组。

DemoRange生成从18到26的页码序列：

using System; using System.Linq; namespace DemoRange { class Program { static void Main(string[] args) { //起始页码 int istart = 18; //结束页码 int iend = 26; var pages = Enumerable.Range(istart, iend - istart + 1); Console.WriteLine("输出页码"); foreach (var n in pages) Console.Write(string.Format("[{0}] ", n)); Console.ReadKey(); } } }

13.Repeat方法：

Repeat方法用于生成指定数量重复元素的序列：

DemoRepeat:生成含有5个相同类型元素的序列

using System; using System.Linq; namespace DemoRepeat { class Program { static void Main(string[] args) { ///定义一个匿名类型 var orange = new {Color="橘色",Name="桔子"}; var oranges = Enumerable.Repeat(orange,5); Console.WriteLine("包含5个匿名类型的元素"); foreach (var n in oranges) Console.WriteLine(string.Format("{0}的{1} ", n.Color, n.Name)); Console.ReadKey(); } } }

14.Empty方法

Empty方法用于获取一个指定的类型参数的空序列。

DemoEmpty:生成String类型的空序列

using System; using System.Collections.Generic; using System.Linq; namespace DemoEmpty { class Program { static void Main(string[] args) { IEnumerable<string> empty = Enumerable.Empty<string>(); Console.WriteLine(string.Format("序列元素数：{0}",empty.Count())); Console.ReadKey(); } } }

15.DefaultIfEmpty方法

DefaultIfEmpty方法用于获取序列，如果序列为空则添加一个类型默认值的元素。例如，元素为引用类型，添加null值元素；元素为int类型，添加int的默认值为0.

DemoDefaultIfEmpty：检测多种类型序列是否为空：

using System; using System.Linq; namespace DemoDefaultIfEmpty { class Program { static void Main(string[] args) { //定义数组 string[] nemes = { "林晚荣", "洛凝", "董巧巧", "依莲", "安碧如" }; //空的int类型序列 var intempty = Enumerable.Empty<int>(); //没有找的元素的序列 var empty = from n in nemes where n == "宁雨昔" select n; Console.WriteLine("DefaultIfEmpty 返回有内容的序列"); foreach (string s in nemes.DefaultIfEmpty()) Console.Write(string.Format("{0} ", s)); Console.WriteLine(string.Format("/nempty 空序列元素数：{0}", intempty.Count())); Console.WriteLine(string.Format("empty 空序列应用DefaultIfEmpty方法后的元素数：{0}", empty.DefaultIfEmpty().Count())); Console.Write(string.Format("empty 空序列应用DefaultIfEmpty方法后的元素值：")); foreach (var s in empty.DefaultIfEmpty()) if (s == null) Console.Write("null"); Console.WriteLine("/n/n****************************************/n"); Console.WriteLine(string.Format("intempty 空序列元素数：{0}", intempty.Count())); Console.WriteLine(string.Format("intempty 空序列应用DefaultIfEmpty方法后的元素数：{0}", intempty.DefaultIfEmpty().Count())); Console.Write(string.Format("intempty 空序列应用DefaultIfEmpty方法后的元素值：")); foreach (var s in intempty.DefaultIfEmpty()) Console.Write(s); Console.ReadKey(); } } }

DemoDefaultIfEmpty2:使用自定义默认值的DefaultIfEmpty方法

using System; using System.Linq; namespace DefaultIfEmpty2 { class Program { static void Main(string[] args) { //空的int类型序列 var intempty = Enumerable.Empty<int>(); Console.Write("int 类型默认值："); foreach (var i in intempty.DefaultIfEmpty()) Console.Write(i); Console.Write("/nint 类型自定义默认值："); foreach (var i in intempty.DefaultIfEmpty(-100)) Console.Write(i); Console.ReadKey(); } } }

16.Cast方法

Cast方法用于按照 TResult类型转换IEnumerable序列的类型。

DemoCast：将ArrayList序列转换成泛型序列

using System; using System.Collections; using System.Collections.Generic; using System.Linq; namespace DemoCast { class Program { static void Main(string[] args) { //定义ArrayList //由于ArrayList没有实现泛型IEnumerable<T>接口， //所以无法用集合初始化器 ArrayList nemes = new ArrayList(); nemes.Add( "林晚荣"); nemes.Add( "洛凝"); nemes.Add( "董巧巧"); nemes.Add( "依莲"); IEnumerable<string> newnames = nemes.Cast<string>(); foreach (string s in newnames) Console.Write(string.Format("{0} ",s)); Console.ReadKey(); } } }

 

17.OfType方法

OfType方法用于根据TResult类型筛选IEnumerable类型序列的元素。它的用途跟Cast方法类似，但OfType方法如果遇到不能强制转换为TResult类型的元素，会丢弃这个元素，而不会出现运行错误。

DemoOfType：使用OfType方法转换ArrayList序列转换成泛型序列：

using System; using System.Collections; using System.Collections.Generic; using System.Linq; namespace DemoOfType { class Program { static void Main(string[] args) { //定义ArrayList ArrayList nemes = new ArrayList(); nemes.Add("林晚荣"); nemes.Add("洛凝"); nemes.Add(100); nemes.Add(new Stack()); nemes.Add("董巧巧"); IEnumerable<string> newnames = nemes.OfType<string>(); foreach (string s in newnames) Console.Write(string.Format("{0} ", s)); Console.ReadKey(); } } }

上面给ArrayList添加了两个无法转换为String类型的元素，应用OfType方法后，将被抛弃。

18.AsEnumerable方法

AsEnumerable方法用与根据元素类型转换为泛型IEnumerable<T>序列。LINQ可以操作多种数据源，而数据源一般使用自己的序列类型，例如LINQ to SQL使用IQueryable<T>类型，IQueryable<T>类型的LINQ扩展方法不进行任何数据操作，它们只负责LINQ表达式拆解为表达式目录树，IEnumerable<T>序列上的一些操作方法，例如Reverse方法，Contains方法等不被IQueryable<T>类型支持，如果需要使用这些操作，就要用AsEnumerable方法，将IQueryable<T>类型转换为IEnumerable<T>类型。

DemoAsEnumerable:将IQueryable类型转换为IEnumerable类型

using System; using System.Collections.Generic; using System.Linq; namespace DemoAsEnumerable { class Program { static void Main(string[] args) { using (FirstLinqToSqlDataContext contex = new FirstLinqToSqlDataContext(Properties.Settings.Default.DbAddressBookConnectionString)) { IQueryable<TabAddressBook> rows = from r in contex.TabAddressBook select r; Console.WriteLine("按照正常的顺序输出记录"); foreach (var n in rows) Console.WriteLine(n.ab_name); Console.WriteLine("/n按照反向顺序输出记录"); try { foreach (var n in rows.Reverse()) Console.WriteLine(n.ab_name); } catch (Exception e) { Console.WriteLine(string.Format("在IQueryable类型上使用Reverse方法出错/n出错信息:{0}",e.Message)); Console.WriteLine("/n转换为IEnumerable类型反向顺序输出"); IEnumerable<TabAddressBook> rows2 = rows.AsEnumerable(); foreach (var n in rows2.Reverse()) Console.WriteLine(n.ab_name); } } Console.ReadKey(); } } }

 

二  用于立即执行的Enumerable类方法成员

1.ToArray方法用于为序列创建一个数组

DemoToArray:将序列转换为数组：

using System; using System.Collections.Generic; using System.Linq; namespace DemoToArray { class Program { static void Main(string[] args) { ///定义List List<string> lst = new List<string>{ "出云公主", "乖巧人儿", "萧家二小姐", "霓裳公主" }; var query = from t in lst where t.IndexOf("公主") > -1 select t; string[] strarray = query.ToArray(); Console.WriteLine(string.Format("lst 类型：{0}", lst.GetType().Name)); Console.WriteLine(string.Format("query 类型：{0}", query.GetType().Name)); Console.WriteLine(string.Format("strarray 类型：{0}", strarray.GetType().Name)); Console.Write("/nstrarray 内容："); foreach (string s in strarray) Console.Write(string.Format(" {0}", s)); Console.ReadKey(); } } }

2.ToList方法

ToList方法用于将序列 转换为泛型  List<T>

DemoToList:将序列 转换为泛型List<T>

using System; using System.Collections.Generic; using System.Linq; namespace DemoToList { class Program { static void Main(string[] args) { ///定义数组 string[] strarray = { "出云公主", "乖巧人儿", "萧家二小姐", "霓裳公主" }; var query = from t in strarray where t.IndexOf("公主") > -1 select t; List<string> lst = query.ToList(); Console.WriteLine(string.Format("strarray 类型：{0}", strarray.GetType().Name)); Console.WriteLine(string.Format("query 类型：{0}", query.GetType().Name)); Console.WriteLine(string.Format("lst 类型：{0}", lst.GetType().Name)); Console.Write("/nlst 内容："); foreach (string s in lst) Console.Write(string.Format(" {0}", s)); Console.ReadKey(); } } }

后面还有很多，大家想学习的话，MSDN上有详细的介绍。