那天有个小孩跟我说LINQ（二）转载

1 LINQ TO Objects续(代码下载)

新建项目 linq_Ch2控制台程序，新建一个Entity文件夹

1.1 学生成绩查询（练习Join）

有三张表如下：学生表，班级表，成绩表。接下来我们按照这个在Entity文件夹建立3个实体类，类名跟表名一样。

    public class StudentInfo

    {

        /// <summary>

        /// 学生编号

        /// </summary>

        public int StuId { get; set; }

        /// <summary>

        /// 学生姓名

        /// </summary>

        public string StuName { get; set; }

        /// <summary>

        /// 班级ID

        /// </summary>

        public int ClassId { get; set; }

        /// <summary>

        /// 班级

        /// </summary>

        public ClassRoom Classrooms { get; set; }

    }

    public class Classroom

    {

        /// <summary>

        /// 班级Id

        /// </summary>

        public int ClassId { get; set; }

        /// <summary>

        /// 班级名称

        /// </summary>

        public string ClassName { get; set; }

    }

    public class Score

    {

        /// <summary>

        /// 分数Id

        /// </summary>

        public int ScoreId { get; set; }

        /// <summary>

        /// 学科名称

        /// </summary>

        public string ItemName { get; set; }

        /// <summary>

        /// 学生ID

        /// </summary>

        public int StuId { get; set; }

        /// <summary>

        /// 学生

        /// </summary>

        public Student Students { get; set; }

        /// <summary>

        /// 分数

        /// </summary>

        public double Scores { get; set; }

    }

如上，3个实体类创建好了

①查询出学生名学科分数 3列信息

首先我们初始化一点数据，在void main方法中写

List<Student> students = new List<Student> {

                 new Student{StuId=,StuName="钱一",ClassId=},

                 new Student{StuId=,StuName="赵二",ClassId=},

                 new Student{StuId=,StuName="张三",ClassId=},

                 new Student{StuId=,StuName="李四",ClassId=},

                 new Student{StuId=,StuName="王五",ClassId=},

                 new Student{StuId=,StuName="陈六",ClassId=},

                 new Student{StuId=,StuName="田七",ClassId=}

              };

            List<Score> scores = new List<Score> {

                 new Score{ScoreId=,ItemName="语文",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="语文",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="语文",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="数学",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="数学",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="数学",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="英语",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="英语",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="英语",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="英语",StuId=,Scores=},

                 new Score{ScoreId=,ItemName="数学",StuId=,Scores=}

            };

            List<ClassRoom> classrooms = new List<ClassRoom> {

                 new ClassRoom{ClassId=,ClassName="高三（1）班"},

                 new ClassRoom{ClassId=,ClassName="高三（2）班"},

                 new ClassRoom{ClassId=,ClassName="高三（3）班"}

             };

开始查询，用集合.Join(另一个集合，第一个集合的条件列，第二个集合的条件列，怎么处理（一个方法）)

            //学生名 学科  分数

            var query1 = students.Join(

                scores,                         //另一个集合

                stu => stu.StuId,         //建立关系stu.StuId=sc.StuId

                sc => sc.StuId,

                (s, sc) => new

                {

                    //选出要的数据

                    学生姓名 = s.StuName,

                    学科 = sc.ItemName,

                    分数 = sc.Scores

                }

                );

            Console.WriteLine("学生姓名\t学科\t\t分数");

            foreach (var stu in query1)

            {

                Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));

            }

            Console.ReadKey();

效果图

第二种方式：

            var query2 = from a in students

                         join b in scores

                         on a.StuId equals b.StuId

                         select new

                         {

                              学生姓名 = a.StuName,

                              学科 = b.ItemName,

                              分数 = b.Scores

                          };

            Console.WriteLine("方式二");

            Console.WriteLine("学生姓名\t学科\t\t分数");

            foreach (var stu in query2)

            {

                Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));

            }

            Console.ReadKey();

②算学生的总分，查出学生名总分

// 学生名  总分（如果分数表找不到，就算0分）

            var query3 = from c in query2

                         group c by c.学生姓名 into stuInfo

                         select new

                        {

                           学生姓名 = stuInfo.Key,

                           学生总分 = stuInfo.Sum(x => x.分数)

                        };

            Console.WriteLine("求总分的案例");

            Console.WriteLine("学生姓名\t总分");

            foreach (var stu in query3)

            {

                Console.WriteLine(string.Format("{0}\t\t{1}", stu.学生姓名, stu.学生总分));

            }

效果图：

③左查询(用join实现),DefaultIfEmpty后面括号中的参数是默认值，以students为主表，scores为副表，主表的信息全显示，副表只显示匹配学生Id相同的。

（如果分数表找不到，就算0分）

Console.WriteLine("左查询方式");

var query5 = from a in students

　　　　　　　　join b in scores

　　　　　　　　on a.StuId equals b.StuId

　　　　　　　　into pGroup

　　　　　　　　from pItem in pGroup.DefaultIfEmpty(new Score { Scores = , ItemName = "没参考", StuId = a.StuId, ScoreId =  })

　　　　　　　　select new

　　　　　　　　{

　　　　　　　　　　学生姓名 = a.StuName,

　　　　　　　　　　学科 = pItem.ItemName,

　　　　　　　　　　分数 = pItem.Scores

　　　　　　　　};

Console.WriteLine("学生姓名\t学科\t\t分数");

foreach (var stu in query5)

{

　　Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));

}

Console.ReadKey();

效果图：

如果是数据库，则等同于SQL语句

select s.StuId,s.StuName,s.ClassID,isnull(sc.ScoreId,0),isnull(sc.itemName,'没参考 '),isnull(sc.stuID,0),isnull(sc.score,0) from dbo.Student s left join dbo.Score sc on s.StuID=sc.stuID

④交叉查询

效果图：

代码：

            Console.WriteLine("交叉查询方式");

            var query6 = from a in students

                         from b in scores

                         select new

                        {

                            学生姓名 = a.StuName,

                            学科 = b.ItemName,

                            分数 = b.Scores

                        };

            Console.WriteLine("学生姓名\t学科\t\t分数");

            foreach (var stu in query6)

            {

                Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));

            }

等同于SQL：

select * from Student,Score

1.2 类型转换操作

①将数据源转换为IEnumerable<T>类型，使用AsEnumerable<T>方法

②将数据源转换为IQueryable<T>类型，使用AsQueryable<T>方法，用法同上

③将数据源转换成字典类型

代码如下：

     //转换成Dictionary

　　  Dictionary<int, Student> query9 = students.ToDictionary(i => i.StuId);

　　  Console.WriteLine(query9[].StuName);

④使用Enumerable类的Cast方法，该方法将非泛型的IEnumerable类型转换为泛型的IEnumerable<T>，至于转换成何种类型有Cast方法的TResult参数指定。

例如：

   ArrayList arrList = new ArrayList();

　　for (int i = ; i < ; i++)

　　{

　　　　arrList.Add(i.ToString());

　　}

　　var query10 = from i in arrList.Cast<string>()

　　　　　　　　　　where i.IndexOf("") > -

　　　　　　　　　　select i;

　　foreach (var item in query10)

　　{

　　　　Console.Write(item+",");

　　}

　　Console.WriteLine();

效果图：

⑤使用 OfType<T> 筛选指定类型的元素

代码如下：

　　//OfType<T>

　　ArrayList arrList2 = new ArrayList();

　　arrList2.Add();

　　arrList2.Add("茗洋");

　　arrList2.Add("A");

　　arrList2.Add();

　　arrList2.Add("dd");

　　var query11=from item in arrList2.OfType<string>()

　　　　　　　　　　select item;

　　foreach (var item in query11)

　　{

　　　　Console.Write(item+",");

　　}

　　Console.WriteLine();

效果图：

⑥将数据源转换为List<T>类型，使用ToList<T>()方法，用法同IQueryable<T>

⑦将数据源转换为数组类型，使用ToArray()方法，用法同IQueryable<T>

⑧转换为一对多的字典Lookup<TKey,TSource>，与Dictionary区别就是相同key会对应多个值

下面我们把班级作为key列出来，然后列出班级里面的学生

var query12 = from o in students
　　　　　　　　join c in classrooms
　　　　　　　　on o.ClassId equals c.ClassId
　　　　　　　　select new Student
　　　　　　　　{
　　　　　　　　　　StuId = o.StuId,
　　　　　　　　　　StuName = o.StuName,
　　　　　　　　　　ClassId = o.ClassId,
　　　　　　　　　　Classrooms = new ClassRoom{
　　　　　　　　　　　　ClassId = c.ClassId,
　　　　　　　　　　　　ClassName = c.ClassName
　　　　　　　　　　}
　　　　　　　  };

            ILookup<string, Student> query13 = query12.ToLookup(f => f.Classrooms.ClassName);

            foreach (var item in query13)
            {
                Console.WriteLine(item.Key + "的学生如下");
                foreach (var stu in item)
                {
                    Console.Write(stu.StuName + ",");
                }
                Console.WriteLine();
            }

效果图如下

1.3 操作集合

. 使用字符串的 EndsWith或者StartsWith过滤，使用CompareTo比较字符串的大小（）

例如：找出以“张”开头的学生姓名

//StartWith

var query14 = from o in query2

　　　　　　　　where o.学生姓名.StartsWith("张")

　　　　　　　　select o;

foreach (var item in query14)

{

　　Console.Write(item.学生姓名+",");

}

Console.WriteLine();

效果图：

其中query2可以是很多，例如List<T>,string[],IQueryable<T>等

. 操作泛型作排序列表SortList<TKey,TValue>

SortList<TKey,TValue>表示按照键进行排序的键/值对的集合，键/值对是KeyValuePair<TKey,TValue>

//SortList
SortedList<int, Student> users = new SortedList<int, Student>
{
　　{2,new Student{StuId=2,StuName="钱一",ClassId=1}},
　　{12,new Student{StuId=12,StuName="赵二",ClassId=1}},
　　{1,new Student{StuId=1,StuName="张三",ClassId=2}},
};

Console.WriteLine("未按学生姓名排序前的结果如下：");

foreach (var item in users)
{
　　Console.Write("     键" + item.Key + "：" + item.Value.StuName);
}

var query15 = from s in users
　　　　　　　　orderby s.Value.StuName descending
　　　　　　　　select s;

Console.WriteLine();

Console.WriteLine("按学生姓名排序后的结果如下：");

foreach (var item in query15)
{
　　Console.Write("     键" + item.Key + "：" + item.Value.StuName);
}

Console.ReadKey();

效果图

. 操作泛型双向链表LinkedList<T>

泛型双向列表LinkedList<T>表示由T指定类型的双向链表，它通过当前元素可以直接访问该元素的前一个或者后一个元素（如果不存在返回空），元素为LinkedListNode<T>类型

效果图：

代码：

　　Console.WriteLine();

　　//LinkedList

　　LinkedList<int> ints2 = new LinkedList<int>();

　　ints2.AddFirst();

　　for (int i = ; i < ; i++)

　　{

　　　　ints2.AddAfter(ints2.Find(i - ), i);

　　}

　　//使用Linq过滤，排序泛型双向链表

　　var query16 = from item in ints2

　　　　　　　　　　where item >  && item <

　　　　　　　　　　orderby item descending

　　　　　　　　　　select item;

　　//显示结果

　　foreach (var item in query16)

　　{

　　　　Console.Write(item.ToString() + ",");

　　}

另一种方式：

　　Console.WriteLine();

　　var query17 = ints2.Where(x => x >  && x < ).OrderByDescending(x => x);

　　//显示结果

　　foreach (var item in query17)

　　{

　　　　Console.Write(item.ToString() + ",");

　　}

. 操作泛型队列Queue<T>

先进先出的线性表，使用Enqueue方法进行元素入队（添加）操作，使用Dequeue方法进行元素出队（删除）操作；使用Clear方法进行清空队列操作。Queue类没有实现IEnumerable<T>接口或IEnumerable接口，所以不能使用LINQ直接操作Queue类型的对象，可以使用Queue对象的Cast方法先把它转换为IEnumerable<T>类型，然后在使用LINQ对齐操作

　　Console.WriteLine();

　　Queue<Student> queues = new Queue<Student>();

　　queues.Enqueue(new Student { StuId=,StuName="大一",ClassId=});

　　queues.Enqueue(new Student { StuId = , StuName = "大二", ClassId =  });

　　queues.Enqueue(new Student { StuId = , StuName = "大三", ClassId =  });

　　queues.Enqueue(new Student { StuId = , StuName = "大四", ClassId =  });

　　var query18 = queues.OrderByDescending(x=>x.StuId);

　　//显示结果

　　foreach (var item in query18)

　　{

　　　　Console.Write(item.StuName + ",");

　　}

效果图：

如果是Queue先转换成IEnumerable<T>，在LINQ操作

. 操作泛型堆栈Stack<T>

后进先出的线性表，使用Push方法进行元素入栈（添加）操作，使用Dequeue方法进行元素出栈（删除）操作；使用Clear方法进行清空堆栈操作。 Stack类没有实现IEnumerable<T>接口或IEnumerable接口，所以不能使用LINQ直接操作Queue类型的对象，可以使用Stack对象的Cast方法先把它转换为IEnumerable<T>类型，然后在使用LINQ对齐操作

效果图：

代码：

　　Console.WriteLine();

　　Stack<Student> stacks = new Stack<Student>();

　　stacks.Push(new Student { StuId = , StuName = "大一", ClassId =  });

　　stacks.Push(new Student { StuId = , StuName = "大二", ClassId =  });

　　stacks.Push(new Student { StuId = , StuName = "大三", ClassId =  });

　　stacks.Push(new Student { StuId = , StuName = "大四", ClassId =  });

　　var query19 = from s in stacks

　　　　　　　　　　where s.ClassId !=  || s.StuId!=

　　　　　　　　　　select s;

　　//显示结果

　　foreach (var item in query19)

　　{

　　　　Console.Write(item.StuName + ",");

　　}

. 操作泛型哈希集HashSet<T>

后泛型哈希集HashSet<T>是由T指定类型的基于集合的模型，泛型哈希集可以提供高性能的如并集，交集，补集等集合运算。泛型哈希集中的元素不能重复。泛型哈希集提供许多集合操作，如并集，交集，补集等。

代码：

　　/*HashSet*/

　　Console.WriteLine();

　　HashSet<Student> hashsets = new HashSet<Student> {

　　　　new Student{StuId=,StuName="钱一",ClassId=},

　　　　new Student{StuId=,StuName="赵二",ClassId=},

　　　　new Student{StuId=,StuName="张三",ClassId=},

　　　　new Student{StuId=,StuName="李四",ClassId=},

　　　　new Student{StuId=,StuName="王五",ClassId=},

　　　　new Student{StuId=,StuName="陈六",ClassId=},

　　　　new Student{StuId=,StuName="田七",ClassId=}

　　};

　　hashsets.Add(new Student { StuId = , StuName = "大一", ClassId =  });

　　//先按班级升序排序，再按姓名降序

　　var query20 = from s in hashsets

　　　　　　　　　　orderby s.ClassId ascending, s.StuName descending

　　　　　　　　　　select s;

　　//显示结果

　　foreach (var item in query20)

　　{

　　　　Console.Write(item.StuName + ",");

　　}

效果图：

. 操作泛型字典Dictionary<TKey,TValue>

键不能重复，值可重复，键不会自动排序

代码：query9是一个Dictionary类型的

　　Console.WriteLine();

　　var query21 = from o in query9

　　　　　　　　　　where o.Value.StuName.CompareTo("张") >  //学生姓名大于“张”

　　　　　　　　　　orderby o.Key

　　　　　　　　　　select o;

　　foreach (var item in query21)

　　{

　　　　Console.WriteLine(item.Key + ":"+item.Value.StuName);

　　}

效果图：

. 操作泛型排序字典SortedDictionary<TKey,TValue>

与Dictionary<TKey,TValue>的区别：泛型排序字典对添加的元素自动按键进行排序,代码例如：SortDictionary<int,Student> c=new SortDictionary<int,Student>{…….}

. 操作泛型通用集合Collection<T>,跟List<T>一样用就行了

. 操作泛型绑定列表 BindingList<T>

泛型绑定列表BindingList<T>能够提供支持数据绑定的泛型集合，他提供了IBindingList接口的具体泛型实现，可以用作创建双向数据绑定机制的积累，还可以通过AddNew方法支持创建实例

跟List<T>一样用就行了

关于还剩一点linq to objects明天写，顺便带点Linq to SQL

巴特西

那天有个小孩跟我说LINQ（二）转载

最新文章

热门文章