LINQ入门教程之各种标准查询操作符（二）

续上篇LINQ入门教程之各种标准查询操作符（一）

        LINQ入门教程之各种标准查询操作符（二）

7．  聚合操作符

 

8．  集合操作符

 

9．  生成操作符

#region   生成操作符 即从现有序列的值中创建新的序列  
        /// <summary>
        /// 返回一个指定类型的空集
        /// </summary>
        static void EmptyFunction()
        {
            string[] name1 = { "1","2" };
            string[] name2={"3","4","5"};
            string[] name3 = { "3", "7", "8", "9" };
            List<string[]> strlists=new List<string[]>{name1,name2,name3};
            //无符合条件，返回空集合
            IEnumerable<string> nameslist = strlists.Aggregate(Enumerable.Empty<string>( ),
                (current, next) => next.Length > 5? current.Union(next) : current);
           
            foreach (string item in nameslist)
            {
                Console.WriteLine(item);
            }
        }
        /// <summary>
        /// 创建一个包含数字序列的集合 包含两个参数，第一个参数是作为序列开始的整数值，第二个参数是要产生的整数序列中数字的个数
        /// </summary>
        static void RangeFunction()
        {
            IEnumerable<int> intAry = Enumerable.Range(2, 5);
            foreach (int item in intAry)
            {
                Console.Write(item + " ");
            }
        }//output: 2 3 4 5 6
        /// <summary>
        /// Repeat 操作符创建一个单值序列,将此值重复一定的次数
        /// </summary>
        static void RepeatFunction()
        {
            IEnumerable<string[]> strAry = Enumerable.Repeat(new string[]{"world","hello"}, 2);
            foreach (string[] item in strAry)
            {
                Console.WriteLine(item[1] +" "+item[0] );
            }
        } 
        //outpupt: 
        //hello world
        //hello world
        #endregion

 

10．  转换操作符

#region  转换操作符  将输入对象的类型转变为序列的动作
        /// <summary>
        /// 将查询的输入以IEnumerable<Of T>类型返回
        /// </summary>
        static void AsEnumerableFunction()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contacts = context.GetTable<Contact>();
            //使用AsEnumerable操作符将类型自带的Where方法替换为标准查询操作符Where的方法
            //这里的Where方法 区分查询条件的大小写,
            //如果用“G”，只能查询出‘G’开头的Firstname，若换做"g",可以查询出所有以g/G开头的Firstname 
            IEnumerable<Contact> query = contacts.AsEnumerable().Where(con=>con.FirstName.Contains("g"));
            foreach (Contact item in query)
            {
                Console.Write(item.FirstName + " ");
            }
            //这里的Where方法 不区分查询条件的大小写 用g/G都可以
            IEnumerable<Contact> query2 = contacts.Where(con => con.FirstName.Contains("G"));
            Console.WriteLine("");
            foreach (Contact item in query2)
            {
                Console.Write(item.FirstName + " ");
            }
        }
        //output:
        //Gong 
        //Gong gong1 gong2 gong3 gong4
        /// <summary>
        /// 将IEnumerable集合中的元素转换为某种指定的类型
        /// </summary>
        static void CastFunction( )
        {
            //ArrayList并不实现IEnumerable(Of T)
            ArrayList names = new ArrayList( );
            var repeatlist = Enumerable.Range(1, 10);
            foreach (int item in repeatlist)
            {
                names.Add(item);
            }
            //通过使用Cast操作符，可以使用标准查询操作符来查询此序列
           IEnumerable<int> query=names.Cast<int>().Select(name=>name);
           foreach (int item in query)
           {
               Console.Write(item +" ");
           }
        }
        //output:
        //1 2 3 4 5 6 7 8 9 10
        /// <summary>
        /// 实现一个基于特定的类型对IEnumerable对象的元素进行过滤
        /// </summary>
        static void OfTypeFunction()
        {
            ArrayList names = new ArrayList(7);
            names.Add("hello");
            names.Add("thank you");
            names.Add(2);
            names.Add(4);
            names.Add("yy");
            names.Add(6);
            //oftype方法返回序列中可以转为int型的元素,通过在IEnumerable对象上使用OfType操作符，就可以使用标准查询操作符来查询此序列
            IEnumerable<int> query = names.OfType<int>();
            foreach (int item in query)
            {
                Console.Write(item+ " ");
            }
        }
        //output:
        //2 4 6
        /// <summary>
        /// 用于实现从一个IEnumerable序列创建一个数组 ,ToArray会强制查询立即执行
        /// </summary>
        static void ToArrayFunction()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contacts = context.GetTable<Contact>();
            var query = contacts.Select(con => con.FirstName).ToArray();
            foreach (string item in query)
            {
                Console.Write(item+" ");
            }
        }
        //output:Gond gong2 gong3 gong4 gong5
        /// <summary>
        /// ToDictionary操作符将序列中的所有返回元素插入到一个Dictionary(Of TKey,TValue)对象中，会强制查询立即执行
        /// </summary>
        static void ToDictionaryFunction()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contact = context.GetTable<Contact>( );
            Dictionary<string, Contact> dict = contact.Where(con=>con.FirstName.Contains("2")).ToDictionary(con => con.FirstName);
            foreach (KeyValuePair<string,Contact> item in dict)
            {
                Console.WriteLine(item.Key+"  "+item.Value.MiddleName);
            }
        }
        //output:
        //gong2 wen2
        /// <summary>
        /// 将一个IEnumerable序列集合转换为一个List(Of T)对象，它也会强制查询立即执行
        /// </summary>
        static void ToListFunction( )
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contact = context.GetTable<Contact>();
            IEnumerable<string> query = (from c in contact where c.FirstName.Contains("2") select c.FirstName).ToList();
            foreach (string item in query)
            {
                Console.WriteLine(item);
            }
        }
        //output: gong2
        /// <summary>
        /// 基于一个特定的主键，将返回的元素放置到一个Lookup(Of Tkey,TElement)对象中
        /// Lookup是主键的集合，每个主键都映射到一个或多个值上，可以认为Lookup对象是一个一对多的字典
        /// </summary>
        static void ToLookupFunction()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contact = context.GetTable<Contact>();
            //Title作为key，Middelname和lastanem作为Element， key对应多个Element
            ILookup<string, string> lkp = contact.ToLookup(con => con.Title, con => con.MiddleName + con.LastName);
            foreach (IGrouping<string,string> item in lkp)
            {
                Console.WriteLine(item.Key);
                foreach (string subitem in item)
                {
                    Console.WriteLine("   "+subitem);
                }
            }
        }
       //output:
        //xinwen2
        //          wentao
        //          wenstaos
        //xinwen 
        //          wen2tao2
        //          wen3tao3
        //          wen4tao4
        //          wen5tao5
        #endregion

 

11．  元素操作符

#region  元素操作符 从一个序列返回单个特定的元素
        /// <summary>
        /// 将一个空集合替换为包含默认的单个值得集合
        /// </summary>
        static void DefaultIfEmptyFunction()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contacts = context.GetTable<Contact>();
            //必须指定类型，用var在foreach时会报错
            IEnumerable<Contact> query=from con in contacts where con.FirstName.StartsWith("gg") select con;
            Contact defaultContact = new Contact() { FirstName="test",MiddleName="defaultIfEmpty"};
            foreach (Contact item in query.DefaultIfEmpty(defaultContact))
                //foreach (string item in query.DefaultIfEmpty("none"))
            {
                Console.Write(item.FirstName+" "+item.MiddleName);
            }
        }
       //output:
       //test defaultIfEmpty
        /// <summary>
        /// ElementAt返回集合中给定索引处的元素。集合是零基（索引从0开始计）的，返回值是数据源中特定位置的元素
        /// ElementAtOrDefault 将ElementAt操作符和DefaultIfEmpty操作符的部分功能结合在一起，返回在某一特定处的元素，如果索引超出范围则返回默认值
        /// </summary>
        static void ElementAtFunction()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contacts = context.GetTable<Contact>( );
            IEnumerable<string> query = from c in contacts where c.FirstName.StartsWith("G") select c.FirstName;
            Console.WriteLine(query.ElementAt(0));
            try
            {
                query.ElementAt(10000);
            }
            catch (Exception ex)
            {
                Console.WriteLine("error:"+ex.Message);
            }
            //超出索引范围 返回默认值
            Console.WriteLine(query.ElementAtOrDefault(10000));
        }
        //output:
        //Gong
        //"error:"+指定的参数已超出有效值的范围
        //参数名：index
        /// <summary>
        /// First查询集合中符合条件的第一个元素 Last查询集合中符合条件的最后一个元素 ，若没有发现任何元素抛出异常
        /// FirstDefault 和LastDefualt，若没有发现任何元素则返回默认值
        /// </summary>
        static void FirstLastFunction()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contacts = context.GetTable<Contact>();
            IEnumerable<Contact> query = from c in contacts select c;
            Contact model = new Contact() {FirstName="test" };
            model = query.First();
            //输出 gong
            Console.WriteLine("First:" + model.FirstName);
            //输出 gong
            model = query.FirstOrDefault();
            Console.WriteLine("FirstDefault" + model.FirstName);
            try
            {
                model = query.Last(con => con == null);
                Console.WriteLine("Last:" + model.FirstName);
            }
            catch (Exception ex)
            {
                //在query.Last处报错，error：序列不包含任何匹配元素
                Console.WriteLine("Last error"+ex.Message);
            }
            model = query.LastOrDefault(con => con == null);
            try
            {
                Console.WriteLine("LastDefault:" + model.FirstName);
            }
            catch (Exception ex)
            {
                //在调用model时报错，error：未将对象引用设置到对象的实例
                Console.WriteLine("LastDefault Error:"+ex.Message);
            }
        }
        /// <summary>
        ///  Single操作符从一个序列中返回单个元素，或唯一满足某一特定条件的元素，如果包含一个以上或没有发现元素则抛出异常
        ///  SingleOrDefault从一个序列中返回单个元素，如果没有发现元素会返回一个默认值，如果返回多个元素，则抛出异常
        /// </summary>
        static void SingleFunction( )
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contacts = context.GetTable<Contact>( );
            IEnumerable<string> quuery = contacts.Where(con => con.FirstName.Equals("Gong2")).Select(con => con.FirstName);
            Console.WriteLine("single:"+quuery.Single());
            IEnumerable<string> query2 = contacts.Where(con => con.FirstName.Equals("test")).Select(con => con.FirstName);
            Console.WriteLine("single default:"+query2.SingleOrDefault());
        }
       //output: 
        //single:gong2
        //single default:
        #endregion

 

12．  相等操作符

    #region  相等操作符
        /// <summary>
        /// SequenceEqual 通过比较两个序列来检查他们相应的元素是否相同，如果序列有相同数量的元素，并且对应元素的值相同，则返回true，否则返回false
        /// </summary>
        static void SequenceEqualFunction()
        {
            int[] numbers1 = { 1, 2, 3, 4, 5, 6, 7 };
            int[] numbers2 = { 1, 2, 3, 4, 5, 6, 7 };
            int[] numbers3 = { 1, 2, 3, 4, 5, 7, 6};
            bool flag = numbers1.SequenceEqual(numbers2);
            Console.WriteLine(flag);
            flag = numbers1.SequenceEqual(numbers3);
            Console.WriteLine(flag);
        }
        //output:
        //True
        //False
        #endregion

 

13．  量词操作符

  #region 量词操作符 返回一个Boolean值，指示序列中是否存在部分或全部元素符合某个特定的条件
        /// <summary>
        ///All 判定在集合中是否所有的值都满足特定的条件，返回值是boolean类型。如果满足，返回true，否则 false。
        /// </summary>
        static void AllFunction()
        {
            Contact[] contacts = { new Contact{FirstName="gwt"}
                                 ,new Contact{FirstName="gwt1"}
                                 ,new Contact{FirstName="gwt2"}
                                 ,new Contact{FirstName="gwt3"}
                                 ,new Contact{FirstName="gwt4"}
                                 ,new Contact{FirstName="lining"}};
            bool flag = contacts.All(name => name.FirstName.StartsWith("gwt"));
            Console.WriteLine("All:"+flag);
            flag = contacts.Any(name => name.FirstName.StartsWith("gwt"));
            Console.WriteLine("Any:"+flag);
            IEnumerable<string> query = contacts.Select(name => name.FirstName);
            flag = query.Contains("gwt");
            Console.WriteLine("Contains:"+flag);
        }
       //output:
        //All:False 
        //Any:True 
        //Contains:True 
        #endregion

 

14．  分割操作符

      #region   分割操作符 是指将一个单一的输入序列划分成两个或多个部分或序列 ，同时不会对输入元素重排序，然后返回一个新形成的部分
        /// <summary>
        /// Skip: 跳过一些元素 到达序列中一个特定的位置
        /// SkipWhile只要特定的条件为真，就继续略过元素，直到出现条件不满足时，返回剩余的元素，剩余的元素不再做判断。
        /// </summary>
        static void SkipFunction()
        {
            IEnumerable<int> query = Enumerable.Range(1, 10);
            IEnumerable<int> query2 = query.Skip(5);
            Console.WriteLine("Skip");
            foreach (int item in query2)
            {
                Console.Write(item + " ");
            }
            Console.WriteLine();
            Console.WriteLine("SkipWhile");
            //条件为num>5, 满足大于5的数被略过，query 为5 4 3 2 1 
            //如果条件为num<5 ,则query集合为10,9,8,7,6,5,4,3,2,1（因为第一个10<5为false，剩余元素不再做判断）这是一个坑啊，弄了半天才整明白
            IEnumerable<int> query3 = (from n in query  orderby n descending select n  ).SkipWhile(num=>num>5);
            foreach (int item in query3)
            {
                Console.Write(item+" ");
            }
             query3 = (from n in query orderby n descending select n).SkipWhile(num => num < 5);
             Console.WriteLine();
            foreach (int item in query3)
            {
                Console.Write(item + " ");
            }
        }
        //output:
        //6 7 8 9 10
        //5 4 3 2 1
        /// <summary>
        /// 返回某个序列中连续的元素子序列，子序列开始于原序列的开头，结束于某个指定的位置。
        /// Take :从序列的开头返回指定数量的连续元素
        /// TakeWhile：只要满足指定的条件，就会返回序列的元素，一旦出现条件不满足，查询不会继续下去，即使后面有满足条件的元素。
        /// </summary>
        static void TakeFunction()
        {
            int[] randomNumbers = { 86,2,77,94,100,65,5,22,70,55,81,66,45};
            IEnumerable<int> takeTopFour = randomNumbers.OrderByDescending(num => num).Take(4);
            Console.Write("Take:");
            foreach (int item in takeTopFour)
            {
                Console.Write(item + " ");
                }
            Console.WriteLine();
            Console.Write("TakeWhile：");
            IEnumerable<int> takeGreaterThan50=(from n in randomNumbers orderby n  select n).TakeWhile(n=>n<50);
            foreach (int item in takeGreaterThan50)
           {
                Console.Write(item+" ");
           }
        }
        //output:
        //Take:100 94 86 81
        //TakeWhile:2 5 22 45
        #endregion

 

最后出一个使用查询操作符的例子

  #region  使用查询操作符
        static void UseSearchOperate()
        {
            DataContext context = new DataContext(StaticData.ConnectSql);
            Table<Contact> contacts = context.GetTable<Contact>();
            Table<Employee> employees = context.GetTable<Employee>();
            //使用查询语法
            var query = from con in contacts
                        join emp in employees on con.ContactID equals emp.ContactID
                        where con.FirstName.StartsWith("gong2")
                        && emp.HireDate.Year > 2012
                        orderby con.FirstName
                        orderby con.LastName
                        select new { emp.EmployeeID, con.LastName, con.FirstName, emp.Title, con.EmailAddress, emp.HireDate };
            //使用方法语法
            var query2 = contacts.Join(employees, con => con.ContactID, emp => emp.ContactID, (con, emp) => new { con = con, emp = emp })
                .Where(c => c.con.FirstName.StartsWith("gong2"))
                .Where(c => c.emp.HireDate.Year > 2012)
                .OrderBy(c => c.con.FirstName)
                .ThenBy(c => c.con.LastName)
                .Select(o=>new {o.con.FirstName,o.con.LastName,o.con.EmailAddress,o.emp.EmployeeID,o.emp.Title,o.emp.HireDate});
            foreach (var item in query2)
            {
                Console.WriteLine(item.FirstName + " " + item.HireDate + " " + item.EmailAddress);
            }
        }
        //output:
        //gong2 2013-08-01 97182234@qq.com
        //gong2 2013-08-01 97182234@qq.com
        //gong2 2013-08-01 97182234@qq.com
        //gong2 2013-08-01 97182234@qq.com
        #endregion

 动动您的手指，点下支持，您的支持是我最大动力！