那天有个小孩跟我说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