程式師世界 >> 編程語言 >> .NET網頁編程 >> C# >> C#入門知識 >> C#應用LINQ中Enumerable類辦法的延遲與立刻履行的掌握

C#應用LINQ中Enumerable類辦法的延遲與立刻履行的掌握

編輯：C#入門知識

C#應用LINQ中Enumerable類辦法的延遲與立刻履行的掌握。本站提示廣大學習愛好者：（C#應用LINQ中Enumerable類辦法的延遲與立刻履行的掌握）文章只能為提供參考，不一定能成為您想要的結果。以下是C#應用LINQ中Enumerable類辦法的延遲與立刻履行的掌握正文

延時履行的Enumerable類辦法

LINQ尺度查詢運算法是依附一組擴大辦法來完成的。而這些擴大辦法分離在System.Linq.Enumerable和System.Linq.Queryable這連個靜態類中界說。

　　Enumerable的擴大辦法采取線性流程，每一個運算法會被線性履行。這類履行辦法假如操作相似關系型數據庫數據源，效力會異常低下，所以Queryable從新界說這些擴大辦法，把LINQ表達式拆解為表達式樹，供給法式便可以依據表達式樹生成關系型數據庫的查詢語句，即SQL敕令，然落後行相干操作。

　　每一個查詢運算符的履行行動分歧，年夜致分為立刻履行和延時履行。延時履行的運算符將在列舉元素的時刻被履行。

　　Enumerable類位於法式集System.Core.dll中，System.Linq定名空間下，而且直接集成自System.Object，存在於3.5及以上的.NET框架中。Enumerable是靜態類，不克不及實例化和被繼續，其成員只要一組靜態和擴大辦法。

　　LINQ不只可以或許查詢完成IEnumerable<T>或IQueryable<T>的類型，也能查詢完成IEnumerable接口的類型。

懂得LINQ起首必需懂得擴大辦法

　　msdn是如許劃定擴大辦法的：“擴大辦法被界說為靜態辦法，但它們是經由過程實例辦法語法停止挪用的。它們的第一個參數指定該辦法感化於哪一個類型，而且該參數以 this 潤飾符為前綴。”

上面給個擴大辦法的例子以下：

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

namespace 擴大辦法
{
  /// <summary>
  /// 為string類型界說一個擴大辦法
  /// </summary>
  static class Helper
  { 
    public static string MyExtenMethod(this string s)
    {
      return s.Substring(0, 2);
    }
  }
  class Program
  {
    static void Main(string[] args)
    {
      string s = "擴大辦法示例";
      Console.WriteLine(s.MyExtenMethod());//挪用
      Console.ReadKey(false);
    }
  }
}

法式的運轉成果以下：

201637145206299.png (677×442)

為了便利懂得和記憶，將經常使用的延時履行的Enumerable類辦法成員分了下組，詳細以下：

1.Take用於從一個序列的開首前往指定命量的元素

2.TakeWhile 用於獲得指定序列從頭開端相符前提的元素，直到碰到不相符前提的元素為止

3.Skip跳過序列中指定命量的元素

4.SkipWhile 用於跳過序列總知足前提的元素，然會前往剩下的元素

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

namespace 延時履行的Enumerable類辦法
{
  class Program
  {
    static void Main(string[] args)
    {
      string[] names = { "DebugLZQ","DebugMan","Sarah","Jerry","Tom","Linda","M&M","Jeffery"};
      //1.Take用於從一個序列的開首前往指定命量的元素
      //
      //a.在數組上直接應用Take辦法
      foreach (string name in names.Take(3))
      {
        Console.Write("{0}  ", name); 
      }
      Console.WriteLine();
      Console.WriteLine("-----");
      //b.在LINQ前往的IEnumerable<T>序列上應用Take辦法
      var query = from string name in names
            where name.Length <=3
            select name;
      foreach (string name in query.Take(1))
      {
        Console.Write("{0}  ",name);
      }
      Console.WriteLine();
      Console.WriteLine("----------------------------");
      Console.ReadKey(false);
      //2.TakeWhile 用於獲得指定序列從頭開端相符前提的元素，直到碰到不相符前提的元素為止
      //
      var takenames = names.TakeWhile(n => n.Length>4);
      var takenames2 = names.TakeWhile((n,i)=>n.Length<10&&i<3);
      foreach (string name in takenames)
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("-----");
      foreach (string name in takenames2)
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("----------------------------");
      Console.ReadKey(false);
      //3.Skip跳過序列中指定命量的元素
      //
      foreach (string name in names.Skip(5))
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("-----");
      var query_skip = (from name in names
               where name.Length >= 3
               select name).Skip(2);
      foreach (string name in query_skip.Skip(2) )
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("----------------------------");
      Console.ReadKey(false);
      //4.SkipWhile 用於跳過序列總知足前提的元素，然會前往剩下的元素
      //跳過名字長度年夜於3的
      var takenames_SkipWhile = names.SkipWhile(n => n.Length >3);
      foreach (string name in takenames_SkipWhile)
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("-----");
      var takenames_SkipWhile2 = names.SkipWhile((n,i)=>n.Length>3&&i>2);
      foreach (string name in takenames_SkipWhile2)
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("----------------------------");
      Console.ReadKey(false);

      //小結Take、Skip取得第N到第M個元素
      var names_TakeAndSkip = names.Skip(5).Take(3);

      var names_TakeAndSkip2 = (from name in names
                   select name).Skip(5).Take(3);

      foreach (string name in names_TakeAndSkip)
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("-----");
      foreach (string name in names_TakeAndSkip2)
      {
        Console.Write("{0}  ", name);
      }
      Console.WriteLine();
      Console.WriteLine("----------------------------");
      Console.ReadKey(false);

    }
  }
}

法式中有具體的正文不再多做解釋，法式運轉成果以下：

201637145251348.png (677×442)

5.Reverse用於翻轉序列中的元素的次序

6.Distinct過濾失落反復的元素

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

namespace Reverse_Distinct等
{
  class Program
  {
    static void Main(string[] args)
    {
      string[] names = { "DebugLZQ", "Jerry", "Sarah", "Jerry", "Tom", "Linda", "M&M", "Jeffery" };
      //5.Reverse用於翻轉序列中的元素的次序
      string str = "反轉字符串";

      var strre = str.ToCharArray().Reverse();
      var takenames = names.Reverse();

      foreach (var c in strre)
      {
        Console.Write(c);
      }
      Console.WriteLine();
      Console.WriteLine("-----");
      foreach (var c in takenames )
      {
        Console.WriteLine(c);
      }
      Console.WriteLine("----------------------------");
      Console.ReadKey(false);

      //6.Distinct 過濾失落反復的元素
      var takenames_Distinct = names.Distinct();

      foreach (var c in takenames_Distinct)
      {
        Console.WriteLine(c);
      }
      Console.WriteLine("----------------------------");
      Console.ReadKey(false);
    }
  }
}

法式的運轉成果以下：

7.Union用於歸並兩個序列，並去失落反復項

8.Concat用於銜接兩個序列，不會去失落反復項

9.Intersect用於取得連個序列的交集

10.Except用於取得兩個聯合的差集

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

namespace Union_Concat_Intersect_Except
{
  /// <summary>
  /// DebugLZQ
  /// http://www.cnblogs.com/DebugLZQ
  /// </summary>
  class Program
  {
    static void Main(string[] args)
    {
      string[] names1 = { "DebugLZQ", "Jerry", "Sarah", "Jerry", "Tom", "Linda", "M&M", "Jeffery" };
      string[] names2 = { "DebugLZQ", "Jerry", "Sarah" };

      //7.Union用於歸並兩個序列，並去失落反復項
      var names_Union = names1.Union(names2);

      //8.Concat用於銜接兩個序列，不會去失落反復項
      var names_Concat = names1.Concat(names2);

      //9.Intersect用於取得連個序列的交集
      var names_Intersect = names1.Intersect(names2);

      //10.Except用於取得兩個聯合的差集
      var names_Except = names1.Except(names2);

      foreach (string name in names_Union)
      {
        Console.WriteLine(name);
      }
      Console.WriteLine("-----");
      Console.ReadKey(false);
      foreach (string name in names_Concat)
      {
        Console.WriteLine(name);
      }
      Console.WriteLine("-----");
      Console.ReadKey(false);
      foreach (string name in names_Intersect)
      {
        Console.WriteLine(name);
      }
      Console.WriteLine("-----");
      Console.ReadKey(false);
      foreach (string name in names_Except)
      {
        Console.WriteLine(name);
      }
      Console.WriteLine("-----");
      Console.ReadKey(false);
    }
  }
}

法式的運轉成果以下：

201637145400103.png (677×442)

11.Range 用於生成指定規模內的“整數”序列

12.Repeat用於生成指定命量的反復元素

13.Empty 用於取得一個指定類型的空序列

14.DefaultIfEmpty 用於取得序列，假如為空，則添加一個默許類型元素

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

namespace Range_Empty_DefalultIfEmpty
{
  /// <summary>
  /// DebugLZQ
  /// http://www.cnblogs.com/DebugLZQ
  /// </summary>
  class Program
  {
    static void Main(string[] args)
    {
      //11.Range 用於生成指定規模內的“整數”序列
      var num2 = Enumerable.Range(10, 15);

      //12.Repeat用於生成指定命量的反復元素
      var guest = new {Name="橙子",Age=25 };
      var Guests = Enumerable.Repeat(guest, 5);

      //13.Empty 用於取得一個指定類型的空序列
      var empty = Enumerable.Empty<string>();

      //14.DefaultIfEmpty 用於取得序列，假如為空，則添加一個默許類型元素
      //a
      var intempty = Enumerable.Empty<int>();
      Console.WriteLine(intempty.Count());
      Console.WriteLine("-----------");
      foreach (var n in intempty)
      {
        Console.WriteLine(n);      
      }
      Console.WriteLine("-----------");
      Console.WriteLine(intempty.DefaultIfEmpty().Count());
      Console.WriteLine("-----------");
      foreach (var n in intempty.DefaultIfEmpty())
      {
        Console.WriteLine(n);
      }
      Console.WriteLine("--------------------------");
      Console.ReadKey(false);
      //b
      string[] names = { "DebugLZQ", "DebugMan", "Sarah", "Jerry", "Tom", "Linda", "M&M", "Jeffery" };
      var query = from name in names
            where name == "LBJ"
            select name;
      Console.WriteLine(query.Count());
      Console.WriteLine(query.DefaultIfEmpty().Count());//默許為null
      foreach (var n in query.DefaultIfEmpty())
      {
        Console.WriteLine(n);
      }
      Console.WriteLine("---------------");
      Console.ReadKey(false);
      //c指定一個默許值
      foreach (var n in intempty.DefaultIfEmpty(100))
      {
        Console.WriteLine(n);
      }
      Console.WriteLine("--------------------------");
      Console.ReadKey(false);

      foreach (var n in query.DefaultIfEmpty("James"))
      {
        Console.WriteLine(n);
      }
      Console.ReadKey(false);
    }
  }
}

法式的運轉成果以下：

201637145430004.png (677×442)

15.OfType挑選指定類型的元素

16.Cast類型轉換

17.AsEnumerable有些數據源類型不支撐Enumerable的部門查詢症結字，須要轉換下，比方IQueryable

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

namespace Cast_OfType_AsEnumerable
{
  /// <summary>
  /// DebugLZQ
  /// http://www.cnblogs.com/DebugLZQ
  /// </summary>
  class Program
  {
    static void Main(string[] args)
    {
      ArrayList names = new ArrayList();
      names.Add("DebugLZQ");
      names.Add("Jerry");
      names.Add(100);
      names.Add(new {Name="LZQ",Age=26});
      names.Add(new Stack());
      //15.OfType挑選指定類型的元素
      var takenames = names.OfType<string>();

      //16.Cast類型轉換
      var takenames2 = names.OfType<string>().Cast<string>();

      //17.AsEnumerable
      var takenames3 = takenames2.AsEnumerable();

      foreach (var name in takenames3)
      {
        Console.Write("{0} ",name);
      }
      Console.ReadKey(false);

    }
  }
}

法式運轉成果以下：

201637145459775.png (677×442)

延時履行，望文生義就是否是立刻履行，即不是在查詢語句界說的時刻履行，而是在處置成果集(如遍歷)的時刻履行，在Enumerable類辦法成員中，除本節總結的這經常使用的17個外，後面博文---LINQ根本子句中總結的8個根本子句也都是延時履行的。留意延時履行的查詢法式的履行流程。

立刻履行的Enumerable類辦法
上面我們再來總結經常使用的立刻履行的Enumerable類辦法和它們的經常使用用法。異樣，為了便於懂得和記憶，停止一下分組：

1.ToArray序列轉換成數組

2.ToList序列轉換成List<T>

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

namespace 立刻履行的Enumerable類辦法成員
{
  class Program
  {
    static void Main(string[] args)
    {
      //1.ToArray序列轉換成數組
      List<string> names =new List<string> { "DebugLZQ","Sarah","Jerry","Jeffrey","M&M"};
      string[] takenames = names.ToArray();

      string[] takenames2 = (from name in names
                 where name.IndexOf("Je")>-1
                 select name).ToArray();

      //2.ToList序列轉換成List<T>
      string[] namesA = { "DebugLZQ", "Sarah", "Jerry", "Jeffrey", "M&M" };
      List<string> takenames_ToList = namesA.ToList();
      List<string> takenames_ToList2 = (from name in namesA select name).ToList();

      //
    }
  }
}

法式成果不言而喻，所以沒有寫輸入語句；
3.ToDictionary把序列轉換為泛型Dictionary<TKey,TValue>

4.ToLookup用於將序列轉換為泛型Lookup<TKey,TValue>

Dictionary和Lookup長短常近似的一對類型，都經由過程“鍵”拜訪相干的元素，分歧的是Dictionary的Key和Value是逐個對應關系，Lookup的Key和Value是一對多關系，Lookup沒有公共結構函數，時能用ToLookup構建，創立後也不克不及刪除Lookup中的元素。

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

namespace ToDictionary
{
  /// <summary>
  /// 3.ToDictionary把序列轉換為泛型Dictionary<TKey,TValue>
  /// </summary>
  class Program
  {
    static void Main(string[] args)
    {
      List<GuestInfo> gList = new List<GuestInfo>() 
      {
        new GuestInfo(){Name="Jeffrey", Age=33,Tel="136********"},
        new GuestInfo(){ Name="DebugLZQ", Age=25,Tel="187********"},
        new GuestInfo(){Name="Sarah", Age=24,Tel="159********"},
        new GuestInfo(){Name="Jerry", Age=33,Tel="135********"},
        new GuestInfo(){Name="Smith", Age=33,Tel="139********"}        
      };
      //ToDictionary把序列轉換為泛型Dictionary
      //ToDictionary重載了4個辦法
      //a.用Name作為Dictionary的“鍵”,guest為“value”
      Dictionary<string, GuestInfo> dictionary1 = gList.ToDictionary(guest => guest.Name);
      foreach (var s in dictionary1 )
      {
        Console.WriteLine("鍵值{0}:{1} {2} {3}",s.Key,s.Value.Name,s.Value.Age,s.Value.Tel );
      }
      Console.WriteLine("--------------------------------");
      Console.ReadKey();
      //b.自界說比擬器      
      Dictionary<string,GuestInfo> dictionary2=gList.ToDictionary(guest=>guest.Name,new MyEqualityComparer<string>());
      foreach (var s in dictionary2)
      {
        Console.WriteLine("鍵值{0}:{1} {2} {3}", s.Key, s.Value.Name, s.Value.Age, s.Value.Tel);
      }
      Console.WriteLine("--------------------------------");
      Console.ReadKey();
      //c.用Name作為Dictionary的“鍵”,Tel屬性為"value"
      Dictionary<string, string> dictionary3 = gList.ToDictionary(guest=>guest.Name,g=>g.Tel);
      foreach (var s in dictionary3)
      {
        Console.WriteLine("鍵值{0}:{1}", s.Key, s.Value);
      }
      Console.WriteLine("--------------------------------");
      Console.ReadKey();
      //d.自界說比擬器
      Dictionary<string, string> dictionary4 = gList.ToDictionary(guest=>guest.Name,g=>g.Tel,new MyEqualityComparer<string>());
      foreach (var s in dictionary4)
      {
        Console.WriteLine("鍵值{0}:{1}", s.Key, s.Value);
      }
      Console.WriteLine("------------------------------------------------------");
      Console.ReadKey();


      ///////////////
      ///4.ToLookup用於將序列轉換為泛型Lookup<TKey,TValue>。
      ///Dictionary和Lookup長短常近似的一對類型，都經由過程“鍵”拜訪相干的元素，分歧的是Dictionary的Key和Value是逐個對應關系
      ///Lookup的Key和Value是一對多關系
      ///Lookup沒有公共結構函數，時能用ToLookup構建，創立後也不克不及刪除Lookup中的元素。
      ///該辦法也有4個原型，和下面的ToDictionary極像
      ///
      //a. Name的第一個字符(字符串)作key
      ILookup<string, GuestInfo> lookup1 = gList.ToLookup(guest => guest.Name.Substring(0, 1));
      foreach (var k in lookup1)
      {
        Console.WriteLine(k.Key);//鍵值
        foreach (var v in k)
        {
          Console.Write("{0},{1},{2}",v.Name,v.Age,v.Tel );
        }
        Console.WriteLine();
      }
      Console.WriteLine("--------------------------------");
      Console.ReadKey();
      //b自界說比擬器
      ILookup<string, GuestInfo> lookup2 = gList.ToLookup(guest => guest.Name.Substring(0, 1), new MyEqualityComparer<string>());
      foreach (var k in lookup2)
      {
        Console.WriteLine(k.Key);//鍵值
        foreach (var v in k)
        {
          Console.Write("{0},{1},{2}", v.Name, v.Age, v.Tel);
        }
        Console.WriteLine();
      }
      Console.WriteLine("--------------------------------");
      Console.ReadKey();
      //c
      ILookup<string, string> lookup3 = gList.ToLookup(guest=>guest.Name.Substring(0,1),g=>g.Name );
      foreach (var k in lookup3)
      {
        Console.WriteLine(k.Key);//鍵值
        foreach (var v in k)
        {
          Console.Write("{0} ", v);
        }
        Console.WriteLine();
      }
      Console.WriteLine("--------------------------------");
      Console.ReadKey();
      //d自界說比擬器
      ILookup<string, string> lookup4 = gList.ToLookup(guest=>guest.Name.Substring(0,1),g=>g.Name,new MyEqualityComparer<string>());
      foreach (var k in lookup4)
      {
        Console.WriteLine(k.Key);//鍵值
        foreach (var v in k)
        {
          Console.Write("{0} ", v);
        }
        Console.WriteLine();
      }
      Console.WriteLine("--------------------------------");
      Console.ReadKey();
    }
  }
}

法式運轉成果以下：

201637145545266.png (669×754)

沒有顯示完整，前面一組輸入和下面最初一組雷同（只是應用了自界說的比擬器）。

5.SequenceEqual 比擬兩個序列能否相等

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

namespace SequenceEqual
{
  /// <summary>
  /// 
  /// </summary>
  class Program
  {
    static void Main(string[] args)
    {
      //5.SequenceEqual 比擬兩個序列能否相等 
      //a比擬兩個序列
      string[] names1 ={ "DebugLZQ","Sarah","Jerry","Jeffrey","M&M"};
      List<string> names2 = new List<string> { "DebugLZQ", "Sarah", "Jerry", "Jeffrey", "M&M" };
      bool equalornot = names1.SequenceEqual(names2);
      bool equalornot2 = names1.Skip(3).Take(2).SequenceEqual(names2.Take(3).SkipWhile(n=>n.Length==3));
      Console.WriteLine("{0},{1}",equalornot,equalornot2 );
      Console.WriteLine("----------------------------");
      Console.ReadKey();
      //b自界說比擬器
      bool equalornot3 = names1.SequenceEqual(names2, new MyEqualityComparer<string>(names2.ToArray()));
      Console.WriteLine("{0}",equalornot3);
      Console.ReadKey();
    }
  }
}

自界說的比擬器以下：

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

namespace SequenceEqual
{
  //DebugLZQ提醒：
  //如不曉得詳細的接話柄現
  //可以用vs供給的主動完成接口功效完成這個接口
  class MyEqualityComparer<T> : IEqualityComparer<T>
  {
    private string[] sec;
    public MyEqualityComparer(string[] s)
    {
      sec = s;
    }
    #region IEqualityComparer<T> 成員

    public bool Equals(T x, T y)
    {
      string temp = x as string;
      if (x != null)
      {
        return sec.Contains(temp);
      }
      return false;
    }

    public int GetHashCode(T obj)
    {
      return obj.GetHashCode();
    }

    #endregion
  }
}

可使用VS主動完成接口的智能提醒，完成接口的完成。
接口的完成方法有“完成接口”和“顯式完成接口”之分，下面這類完成方法即“顯示接口”方法，“顯示完成接口”最明顯的特點是完成的接口辦法加了個完整限制名，如許顯式完成以後，沒法經由過程詳細的類名來拜訪接口辦法，只能經由過程接口名來拜訪，如許可以隱蔽類的龐雜性。

法式運轉成果以下：

201637145630906.png (677×138)

6.First 前往序列第一個知足前提元素

7.FirstOrDefault 前往序列第一個知足前提元素，假如沒有找到則前往默許值

8.Last

9.LastOrDefault

10.Single前往序列中獨一的元素，假如序列中包括多個元素，會激發運轉毛病！

11.SingleOrDefault 找出序列中知足必定前提的元素，假如序列為空則前往默許值，假如序列中包括多個多個元素會激發運轉毛病！！

12.ElementAt 取得指定索引處的元素

13.ElementAtOrDefault 取得指定索引處的元素，假如超越索引，則前往元素類型的默許值

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

namespace First_FirstOrDefault_Last_LastOrDefault_ElementAt_ElementAtOrDefaul
{
  class Program
  {
    static void Main(string[] args)
    {
      //6.First
      string[] names = { "DebugLZQ", "Sarah", "Jerry", "Jeffrey", "M&M" };
      var item = names.First();
      var item2 = names.First(n => n == "Sarah");
      Console.WriteLine("{0},{1}",item,item2 );
      Console.ReadKey();
      //7.FirstOrDefault
      var item3 = names.FirstOrDefault();
      var item4 = names.FirstOrDefault(n => n == "Sarah");
      Console.WriteLine("{0},{1}", item3, item4);
      Console.ReadKey();
      //8.Last
      var item5 = names.Last();
      var item6 = names.LastOrDefault(n => n == "Sarah");
      Console.WriteLine("{0},{1}", item5, item6);
      Console.ReadKey();
      //9LastOrDefault
      var item7 = names.LastOrDefault();
      var item8 = names.LastOrDefault(n => n == "Sarah");
      Console.WriteLine("{0},{1}", item7, item8);
      Console.ReadKey();
      //10.Single前往序列中獨一的元素，假如序列中包括多個元素，會激發運轉毛病！
      try
      {
        var item9 = names.Single();
      }
      catch(Exception ex)
      {
        Console.WriteLine(ex.Message);
      }
      //
      var item10 = names.Single(n => n == "Sarah");
      Console.WriteLine("{0}",item10 );
      Console.ReadKey();
      //11.SingleOrDefault 找出序列中知足必定前提的元素，假如序列為空則前往默許值， 假如序列中包括多個多個元素會激發運轉毛病！！
      try
      {
        var item11 = Enumerable.Empty<string>().SingleOrDefault();
        Console.WriteLine("{0}",item11);//不報錯，假如序列為空就前往默許值 
      }
      catch (Exception ex)
      {
        Console.WriteLine(ex.Message );
      }
      try
      {
        var item12 = names.SingleOrDefault();
        Console.WriteLine("{0}", item12);//報錯，序列包括多行毛病
      }
      catch (Exception ex)
      {
        Console.WriteLine(ex.Message);
      }
      var item13 = Enumerable.Empty<string>().DefaultIfEmpty("DebugLZQ").SingleOrDefault();
      Console.WriteLine("{0}", item13);
      var item14 = names.SingleOrDefault(n => n == "xxx");
      Console.WriteLine("{0}", item14);
      Console.ReadKey();
      //12ElementAt 取得指定索引處的元素
      var item15 = names.ElementAt(3);
      Console.WriteLine("{0}", item15);
      Console.ReadKey();
      //13ElementAtOrDefault 取得指定索引處的元素，假如超越索引，則前往元素類型的默許值
      var item16 = names.ElementAtOrDefault(3);
      var item17 = names.ElementAtOrDefault(100);
      Console.WriteLine("{0},{1}",item16,item17);
      Console.ReadKey();
    }
  }
}

法式運轉成果以下：

201637145709767.png (677×266)

14.All序列中的一切元素能否都知足前提

15.Any序列中的元素能否存在或知足前提

16.Contains肯定元素能否在序列中

17.Count序列包括元素的數目

18.LongCount獲得一個Int64類型的元素數目

19.Aggregate將序列元素停止累加

20.Sum序列之和

21.Average序列均勻值

22.Min序列的最小值

23.Max序列的最年夜值

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

namespace All_Any_Count_LongCount_Aggregate_SumAverage_Min_Max
{
  class Program
  {
    static void Main(string[] args)
    {
      string[] names = { "DebugLZQ", "Sarah", "Jerry", "Jeffrey", "M&M" };
      //14All序列中的一切元素能否都知足前提
      bool b1 = names.All(s=>s.GetTypeCode()==TypeCode.String );
      bool b2 = names.All(s=>s.IndexOf("S")>-1);
      Console.WriteLine("{0},{1}",b1,b2);
      Console.ReadKey();
      Console.WriteLine("----------------------");
      //15Any序列中的元素能否存在或知足前提
      bool p1 = names.Any();
      bool p2 = names.Any(s => s.IndexOf("S")>-1);
      Console.WriteLine("{0},{1}", p1, p2);
      Console.ReadKey();
      Console.WriteLine("----------------------");
      //16Contains肯定元素能否在序列中
      //a
      bool q1 = names.Contains("MM");
      //b自界說比擬函數
      bool q2 = names.Contains("MM", new MyEqualityComparer<string>());
      Console.WriteLine("{0},{1}", q1, q2);
      Console.ReadKey();
      Console.WriteLine("----------------------");
      //17Count序列包括元素的數目
      int i1 = names.Count();
      int i2 = names.Count(n => n.Length == 5);
      Console.WriteLine("{0},{1}", i1, i2);
      Console.ReadKey();
      Console.WriteLine("----------------------");
      //18LongCount獲得一個Int64類型的元素數目
      long j1 = names.LongCount();
      long j2 = names.LongCount(n => n.Length == 5);
      Console.WriteLine("{0},{1}",j1, j2);
      Console.ReadKey();
      Console.WriteLine("----------------------");
      //19Aggregate將序列元素停止累加
      int[] nums = { 10,20,30,40,50};
      int a1 = nums.Aggregate((n1,n2)=>n1+n2);//150
      int a2 = nums.Aggregate(50,(n1,n2)=>n1+n2);//200      
      Console.WriteLine("{0},{1}", a1, a2);
      string s1 = names.Aggregate((name1,name2)=>string.Format("{0}、{1}",name1,name2));
      string s2= names.Aggregate("The result is ",(name1, name2) => string.Format("{0}、{1}", name1, name2));
      Console.WriteLine("{0}", s1); 
      Console.WriteLine("{0}", s2);
      Console.ReadKey();
      Console.WriteLine("----------------------");
      //20Sum序列之和
      int sum = nums.Sum();
      //21Average序列均勻值
      double avg = nums.Average();
      //22Min序列的最小值
      int min = nums.Min();
      //23Max序列的最年夜值
      int max=nums.Max();
      Console.WriteLine("{0},{1},{2},{3}", sum, avg,min,max);
      Console.ReadKey();
      
    }
  }
}

法式運轉成果以下：

201637145734802.png (677×442)