关于LINQ查询相关

    LINQ查询：

（复制于）

1.     ·First - 返回集合中的第一个元素；不延迟  
2.     ·FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟  
3.     ·Last - 返回集合中的最后一个元素；不延迟  
4.     ·LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）  
5.     ·ElementAt - 返回集合中指定索引的元素；不延迟  
6.     ·ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟  
7.     ·Contains - 判断集合中是否包含有某一元素；不延迟  
8.     ·Any - 判断集合中是否有元素满足某一条件；不延迟  
9.     ·All - 判断集合中是否所有元素都满足某一条件；不延迟  
10.     ·Count - 返回集合中的元素个数，返回int；不延迟  
11.     ·LongCount - 返回集合中的元素个数，返回long；不延迟  
12.     ·Sum - 集合应为数字类型集合，求其和；不延迟  
13.     ·Min - 返回集合的最小值；不延迟  
14.     ·Max - 返回集合的最大值；不延迟  
15.     ·Average - 集合应为数字类型集合，求其平均值；不延迟  
16.     ·Aggregate - 根据输入的表达式获取一个聚合值；不延迟  
17.     ·Cast - 将集合转换为强类型集合；延迟  
18.     ·DefaultIfEmpty - 查询结果为空则返回默认值；延迟  
19.     ·SequenceEqual - 判断两个集合是否相同；不延迟  
20.     ·OfType - 过滤集合中的指定类型；延迟  
21.     ·ToArray - 将集合转换为数组；不延迟  
22.     ·ToList - 将集合转换为List<T>集合；不延迟  
23.     ·ToDictionary - 将集合转换为<K, V>集合；不延迟  

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LINQ_Demo1
{
    class Program
    {
       static string[] _ary ;
       static string s;
        static void Main(string[] args)
        {
           
            //创建一个
            _ary = new string[] {"第1个", "第2个", "第3个", "第4个", "第5个",
            "第6个","第7个","第7个","第8个","第9个","第10个","第11个",
            "第12个","第13个","第14个","第15个","第16个","第17个","第18个"};
            //First:返回集合中的第一个元素；不延迟
            //FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟 
            // Summary_First();

            // Last - 返回集合中的最后一个元素；不延迟  
            // LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）  
            //  Summary_Last_LastOrDefault();

            // ElementAt - 返回集合中指定索引的元素；不延迟  
            // ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟  
            // Summary_ElementAt_ElementAtOrDefault();

            // Contains - 判断集合中是否包含有某一元素；不延迟  
            // Summary_Contains();

            // Any - 判断集合中是否有元素满足某一条件；不延迟  
            // Summary_Any();

            // All - 判断集合中是否所有元素都满足某一条件；不延迟  
            //   Summary_All();

            // Count - 返回集合中的元素个数，返回int；不延迟  
            // LongCount - 返回集合中的元素个数，返回long；不延迟  
            // Summary_Count_LongCount();

            // Sum - 集合应为数字类型集合，求其和；不延迟  
            // Summary_Sum();

            // Min - 返回集合的最小值；不延迟  
            //   Summary_Min();
            // Max - 返回集合的最大值；不延迟  
            //   Summary_Max();
            // Average - 集合应为数字类型集合，求其平均值；不延迟  
            //Summary_Average();
            // Aggregate - 根据输入的表达式获取一个聚合值；不延迟  
            // Summary_Aggregate();
            // Cast - 将集合转换为强类型集合；延迟  
            // Summary_Cast();

            // DefaultIfEmpty - 查询结果为空则返回默认值；延迟  
            //   Summary_DefaultIfEmpty();

            // SequenceEqual - 判断两个集合是否相同；不延迟  
            //  Summary_SequenceEqual();

            // OfType - 过滤集合中的指定类型；延迟  
            // Summary_OfType();

            // ToArray - 将集合转换为数组；不延迟  
           // Summary_ToArray();

            // ToList - 将集合转换为List<T>集合；不延迟  
          //  Summary_ToList();

            // ToDictionary - 将集合转换为<K, V>集合；不延迟  
           // Summary_ToDictionary();
            Console.ReadKey();
        }
      static  void Summary_First()
        {
            //string s = (from a in _ary select a).First(a=>a.StartsWith("1"));
             s = (from a in _ary
                        select a).FirstOrDefault(a => a.StartsWith("第2个"));

        }
        static void Summary_Last_LastOrDefault()
        {
            string s = (from a in _ary select a).Last(a=>a.StartsWith(""));
           string  c = (from a in _ary
                 select a).LastOrDefault(a => a.StartsWith(""));
            Console.WriteLine(c);
        }

        static void Summary_ElementAt_ElementAtOrDefault()
        {
            string s = (from a in _ary select a).ElementAt(3);
            string c = (from a in _ary
                        select a).ElementAtOrDefault(5);
            Console.WriteLine(s);
            Console.WriteLine(c);
        }

        static void Summary_Contains()
        {
            bool c = (from a in _ary select a).Contains("第2个");
          
            Console.WriteLine(c);
         
        }
        static void Summary_Any()
        {
            bool c = (from a in _ary select a).Any(p=>p.Length>10);

            Console.WriteLine(c);

        }

        static void Summary_All()
        {
            bool c = (from a in _ary select a).All(p => p.Length > 10);

            Console.WriteLine(c);

        }
        static void Summary_Count_LongCount()
        {
            int c = (from a in _ary select a).Count(p => p.Length > 10);
            //long i = (from a in _ary
            //          select a).LongCount(p => p.length > 10);
            Console.WriteLine(c);

        }
        static void Summary_Sum()
        {
            int c = (from a in _ary select a.Length).Sum();
            //long i = (from a in _ary
            //          select a).LongCount(p => p.length > 10);
            Console.WriteLine(c);

        }
        static void Summary_Min()
        {
            int c = (from a in _ary select a.Length).Min();
            //long i = (from a in _ary
            //          select a).LongCount(p => p.length > 10);
            Console.WriteLine(c);

        }
        static void Summary_Max()
        {
            int c = (from a in _ary select a.Length).Max();
            //long i = (from a in _ary
            //          select a).LongCount(p => p.length > 10);
            Console.WriteLine(c);

        }
        static void Summary_Average()
        {
            double c = (from a in _ary select a.Length).Average();
            //long i = (from a in _ary
            //          select a).LongCount(p => p.length > 10);
            Console.WriteLine(c);

        }
        static void Summary_Aggregate()
        { // 以下算法的Aggregate相当于Sum  
            double c = (from a in _ary select a.Length).Aggregate((x,y)=>x+y);
            //long i = (from a in _ary
            //          select a).LongCount(p => p.length > 10);
            Console.WriteLine(c);

        }
        static void Summary_Cast()
        {
            ArrayList al = new ArrayList();
            al.Add("第一个");
            al.Add("第二个");
            al.Add("第三个");
            var list = al.Cast<string>();
            foreach (string  s in list)
            {
                Console.WriteLine(s);

            }
        }
        static void Summary_DefaultIfEmpty()
        {
            var list = (from a in _ary
                        where a.Length > 100
                        select a).DefaultIfEmpty("以第一");

            foreach (string s in list)
            {
                Console.WriteLine(s);
            }

        }

        static void Summary_SequenceEqual()
        {
            bool b = (from a in _ary where a.Length > 3 select a).SequenceEqual(
                from a in _ary where a.Length > 3 select a);
            Console.WriteLine(b);

        }
        static void Summary_OfType()
        {
            object[] obj = { 1,"1",2,"b",3,"c"};
            var liat = obj.OfType<string>();
            Console.WriteLine(liat);

        }
        static void Summary_ToArray()
        {
          // string [] ary=(from p in _)
          //  Console.WriteLine(liat);

        }
        static void Summary_ToList()
        {
            var list = (from a in _ary where a.Length > 3 select a).ToList();

            Console.WriteLine(list);

        }

    }
   
}