C#使用LINQ中Enumerable類方法的延遲與立即執(zhí)行的控制
更新時間：2016年03月07日 14:59:54 作者：DebugLZQ
這篇文章主要介紹了C#的LINQ查詢中Enumerable類方法的延遲與立即執(zhí)行,LINQ語言集成查詢可以讓C#和VB以查詢數據庫相同的方式操作內存數據,需要的朋友可以參考下
延時執(zhí)行的Enumerable類方法
LINQ標準查詢運算法是依靠一組擴展方法來實現的。而這些擴展方法分別在System.Linq.Enumerable和System.Linq.Queryable這連個靜態(tài)類中定義。
Enumerable的擴展方法采用線性流程，每個運算法會被線性執(zhí)行。這種執(zhí)行方法如果操作類似關系型數據庫數據源，效率會非常低下，所以Queryable重新定義這些擴展方法，把LINQ表達式拆解為表達式樹，提供程序就可以根據表達式樹生成關系型數據庫的查詢語句，即SQL命令，然后進行相關操作。
每個查詢運算符的執(zhí)行行為不同，大致分為立即執(zhí)行和延時執(zhí)行。延時執(zhí)行的運算符將在枚舉元素的時候被執(zhí)行。
Enumerable類位于程序集System.Core.dll中，System.Linq命名空間下，并且直接集成自System.Object，存在于3.5及以上的.NET框架中。Enumerable是靜態(tài)類，不能實例化和被繼承，其成員只有一組靜態(tài)和擴展方法。
LINQ不僅能夠查詢實現IEnumerable<T>或IQueryable<T>的類型，也能查詢實現IEnumerable接口的類型。
理解LINQ首先必須理解擴展方法
msdn是這樣規(guī)定擴展方法的：“擴展方法被定義為靜態(tài)方法，但它們是通過實例方法語法進行調用的。 它們的第一個參數指定該方法作用于哪個類型，并且該參數以 this 修飾符為前綴?！?/p>
下面給個擴展方法的例子如下：
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);
}
}
}
程序的運行結果如下：
為了方便理解和記憶，將常用的延時執(zhí)行的Enumerable類方法成員分了下組，具體如下：
1.Take用于從一個序列的開頭返回指定數量的元素
2.TakeWhile 用于獲取指定序列從頭開始符合條件的元素，直到遇到不符合條件的元素為止
3.Skip跳過序列中指定數量的元素
4.SkipWhile 用于跳過序列總滿足條件的元素，然會返回剩下的元素
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 延時執(zhí)行的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);
}
}
}
程序中有詳細的注釋不再多做說明，程序運行結果如下：
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);
}
}
}
程序的運行結果如下：
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);
}
}
}
程序的運行結果如下：
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);
}
}
}
程序運行結果如下：
延時執(zhí)行，顧名思義就是不是立即執(zhí)行，即不是在查詢語句定義的時候執(zhí)行，而是在處理結果集(如遍歷)的時候執(zhí)行，在Enumerable類方法成員中，除了本節(jié)總結的這常用的17個外，前面博文---LINQ基本子句 中總結的8個基本子句也都是延時執(zhí)行的。注意延時執(zhí)行的查詢程序的執(zhí)行流程。
立即執(zhí)行的Enumerable類方法
下面我們再來總結常用的立即執(zhí)行的Enumerable類方法和它們的常用用法。同樣，為了便于理解和記憶，進行一下分組：
1.ToArray序列轉換成數組
2.ToList序列轉換成List<T>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 立即執(zhí)行的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構建，創(chuàng)建后也不能刪除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構建，創(chuàng)建后也不能刪除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();
}
}
}
程序運行結果如下：
沒有顯示完全，后面一組輸出和上面最后一組相同（只是使用了自定義的比較器）。
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自動實現接口的智能提示，完成接口的實現。
接口的實現方式有“實現接口”和“顯式實現接口”之分，上面這種實現方式即“顯示接口”方式，“顯示實現接口”最顯著的特征是實現的接口方法加了個完全限定名，這樣顯式實現之后，無法通過具體的類名來訪問接口方法，只能通過接口名來訪問，這樣可以隱藏類的復雜性。
程序運行結果如下：
6.First 返回序列第一個滿足條件元素
7.FirstOrDefault 返回序列第一個滿足條件元素，如果沒有找到則返回默認值
8.Last
9.LastOrDefault
10.Single返回序列中唯一的元素，如果序列中包含多個元素，會引發(fā)運行錯誤！
11.SingleOrDefault 找出序列中滿足一定條件的元素，如果序列為空則返回默認值， 如果序列中包含多個多個元素會引發(fā)運行錯誤??！
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返回序列中唯一的元素，如果序列中包含多個元素，會引發(fā)運行錯誤！
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 找出序列中滿足一定條件的元素，如果序列為空則返回默認值， 如果序列中包含多個多個元素會引發(fā)運行錯誤?。?
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();
}
}
}
程序運行結果如下：
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();
}
}
}
程序運行結果如下：
相關文章
這篇文章主要介紹了改進c# 代碼的五個技巧（一），幫助大家更好的理解和使用c#,感興趣的朋友可以了解下2021-01-01
C# 中 System.Index 結構體和 Hat 運算符(^)的使用示例
這篇文章主要介紹了C# 中 System.Index 結構體和 Hat 運算符(^)的使用示例,幫助大家更好的理解和使用C#,感興趣的朋友可以了解下2020-09-09
本文主要介紹了C#實現輸入法的相關知識。具有很好的參考價值。下面跟著小編一起來看下吧2017-03-03
這篇文章主要為大家詳細介紹了Unity3D實現簡易五子棋源碼，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-09-09
這篇文章主要介紹了C#如何將查詢到的數據庫里面的數據輸出到textbox控件問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-07-07
這篇文章主要為大家詳細介紹了C#生成驗證碼圖片的方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-10-10
這篇文章主要為大家詳細介紹了Unity3D創(chuàng)建圓柱體的方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-02-02
本文給大家介紹WPF自動隱藏的消息框實例代碼，當鼠標放上去將一直顯示，移開動畫繼續(xù)，提供normal和error兩種邊框。非常不錯，具有參考借鑒價值，感興趣的朋友一起看下吧2016-07-07
這篇文章主要介紹了C#日期控件datetimepicker保存空值的三種方法,本文分別講解了三種方法的實現原理和代碼示例,需要的朋友可以參考下2015-06-06
Mesh是指模型的網格，3D模型是由多邊形拼接而成，而多邊形實際上是由多個三角形拼接而成的，今天通過本文給大家介紹Unity中 mesh生成斜坡功能，感興趣的朋友一起看看吧2021-05-05