C\#LINQ 에서 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
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);
}
}
}
이해 와 기억 을 위해 자주 사용 하 는 지연 실행 방법 인 Enumerable 클래스 의 멤버 를 다음 그룹 으로 나 누 었 습 니 다.구체 적 으로 다음 과 같 습 니 다.
1.Take 는 한 시퀀스 의 시작 에서 지정 한 수량의 요 소 를 되 돌려 줍 니 다.
2.TakeWhile 은 조건 에 맞지 않 는 요 소 를 만 날 때 까지 지 정 된 시퀀스 를 처음부터 조건 에 맞 는 요 소 를 가 져 오 는 데 사 용 됩 니 다.
3.건 너 뛰 기 시퀀스 에서 지정 한 수량의 요소
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);
}
}
}
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.캐 스 트 유형 변환
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);
}
}
}
지연 실행 은 말 그대로 바로 실행 되 는 것 이 아 닙 니 다.즉,검색 어 정의 때 실행 되 는 것 이 아니 라 처리 결과 집(예 를 들 어 옮 겨 다 니 는 것)때 실 행 됩 니 다.Enumerable 류 방법 구성원 중에서 이 절 에서 자주 사용 하 는 17 개 를 제외 하고 앞의 박문-LINQ 기본 자구 에서 총 결 된 8 개의 기본 자구 도 모두 지연 되 어 실 행 됩 니 다.지연 되 는 조회 프로그램의 실행 절 차 를 주의 하 십시오.
즉시 실행 되 는 Enumerable 클래스 방법
다음 에 자주 사용 하 는 즉시 실행 되 는 Enumerable 류 방법 과 그들의 상용 용법 을 정리 하 겠 습 니 다.마찬가지 로 이해 와 기억 에 편리 하도록 조 를 나 누 어 보 자.
1.ToArray 시퀀스 를 배열 로 변환
2.ToList 시퀀스 를 List
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
4.ToLookup 은 시퀀스 를 범용 Lookup
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();
}
}
}
완전히 표시 되 지 않 았 습 니 다.뒤의 출력 은 위의 마지막 그룹 과 같 습 니 다.(사용자 정의 비교 기 만 사 용 했 습 니 다.)
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
}
}
인터페이스의 실현 방식 은'실현 인터페이스'와'현식 실현 인터페이스'의 구분 이 있다.위의 이러한 실현 방식 은 바로'디 스 플레이 인터페이스'방식 이다.'디 스 플레이 실현 인터페이스'의 가장 현저 한 특징 은 실 현 된 인터페이스 방법 에 완전한 한정 명 을 추가 하 는 것 이다.이렇게 현식 이 실 현 된 후에 구체 적 인 유형 명 을 통 해 인터페이스 방법 에 접근 할 수 없고 인터페이스 명 을 통 해 만 접근 할 수 있다.이렇게 하면 종류의 복잡성 을 숨 길 수 있다.
프로그램 실행 결 과 는 다음 과 같 습 니 다.
6.First 반환 시퀀스 첫 번 째 만족 조건 요소
7.First OrDefault 는 첫 번 째 만족 조건 요 소 를 되 돌려 줍 니 다.찾 지 못 하면 기본 값 을 되 돌려 줍 니 다.
8.Last
9.LastOrDefault
10.Single 반환 시퀀스 의 유일한 요 소 는 시퀀스 에 여러 요 소 를 포함 하면 실행 오류 가 발생 할 수 있 습 니 다!
11.SingleOrDefault 는 시퀀스 에 일정한 조건 을 만족 시 키 는 요 소 를 찾 습 니 다.시퀀스 가 비어 있 으 면 기본 값 을 되 돌려 줍 니 다.시퀀스 에 여러 개의 요소 가 포함 되 어 있 으 면 실행 오류 가 발생 합 니 다!
12.Element At 에서 지정 한 색인 에 있 는 요 소 를 가 져 옵 니 다.
13.Element AtOrDefault 는 지정 한 색인 에 있 는 요 소 를 가 져 옵 니 다.색인 을 초과 하면 요소 형식의 기본 값 을 되 돌려 줍 니 다.
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();
}
}
}
14.All 시퀀스 의 모든 요소 가 조건 을 만족 시 키 는 지 여부
15.Any 시퀀스 의 요소 가 존재 하거나 조건 을 만족 시 키 는 지 여부
16.Contains 요소 가 시퀀스 에 있 는 지 확인
17.Count 시퀀스 에 포 함 된 요소 의 수량
18.LongCount 에서 Int 64 유형의 요 소 를 가 져 옵 니 다.
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();
}
}
}
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Excel 데이터를 LINQ에서 검색이 문서에서는 을 통해 LINQ를 사용하여 Excel 테이블에 액세스하는 방법을 설명합니다. 이렇게 하려면 Entity Framework에 LINQ를 사용합니다. 이렇게 하면 연결을 만들고 모든 CData ADO.N...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
