linq
표준 쿼리 연산자

비고

연결 작업

병합이란 한 시퀀스를 다른 시퀀스에 추가하는 작업을 말합니다.

콩 카트

두 시퀀스를 연결하여 하나의 시퀀스를 형성합니다.

메서드 구문

// Concat

var numbers1 = new int[] { 1, 2, 3 };
var numbers2 = new int[] { 4, 5, 6 };

var numbers = numbers1.Concat(numbers2);

// numbers = { 1, 2, 3, 4, 5, 6 }

검색어 구문

// Not applicable.

필터링 작업

필터링이란 지정된 조건을 만족하는 요소 만 포함하도록 결과 집합을 제한하는 작업을 의미합니다.

어디에

술어 기능을 기본으로하는 값을 선택합니다.

메서드 구문

// Where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

var evens = numbers.Where(n => n % 2 == 0);

// evens = { 2, 4, 6, 8 }

검색어 구문

// where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

var odds = from n in numbers
           where n % 2 != 0
           select n;

// odds = { 1, 3, 5, 7 }

OfType

지정된 유형으로 형변환 할 수 있는지 여부에 따라 값을 선택합니다.

메서드 구문

// OfType

var numbers = new object[] { 1, "one", 2, "two", 3, "three" };

var strings = numbers.OfType<string>();

// strings = { "one", "two", "three" }

검색어 구문

// Not applicable.

조인 작업

두 데이터 소스의 조인은 한 데이터 소스의 오브젝트와 다른 데이터 소스의 공통 속성을 공유하는 오브젝트의 연관입니다.

어울리다

키 선택기 함수를 기반으로 두 시퀀스를 결합하고 값 쌍을 추출합니다.

메서드 구문

// Join

class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Order
{
    public string Description { get; set; }
    public int CustomerId { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Id = 1, Name = "C1" },
    new Customer { Id = 2, Name = "C2" },
    new Customer { Id = 3, Name = "C3" }
};

var orders = new Order[]
{
    new Order { Description = "O1", CustomerId = 1 },
    new Order { Description = "O2", CustomerId = 1 },
    new Order { Description = "O3", CustomerId = 2 },
    new Order { Description = "O4", CustomerId = 3 },
};

var join = customers.Join(orders, c => c.Id, o => o.CustomerId, (c, o) => c.Name + "-" + o.Description);

// join = { "C1-O1", "C1-O2", "C2-O3", "C3-O4" }

검색어 구문

// join … in … on … equals …

var join = from c in customers
           join o in orders
           on c.Id equals o.CustomerId
           select o.Description + "-" + c.Name;

// join = { "O1-C1", "O2-C1", "O3-C2", "O4-C3" }

그룹 조인

키 선택기 함수를 기반으로 두 개의 시퀀스를 결합하고 각 요소에 대해 일치하는 결과를 그룹화합니다.

메서드 구문

// GroupJoin

var groupJoin = customers.GroupJoin(orders,
                                    c => c.Id, 
                                    o => o.CustomerId, 
                                    (c, ors) => c.Name + "-" + string.Join(",", ors.Select(o => o.Description)));

// groupJoin = { "C1-O1,O2", "C2-O3", "C3-O4" }

검색어 구문

// join … in … on … equals … into …

var groupJoin = from c in customers
                join o in orders               
                on c.Id equals o.CustomerId
                into customerOrders
                select string.Join(",", customerOrders.Select(o => o.Description)) + "-" + c.Name;

// groupJoin = { "O1,O2-C1", "O3-C2", "O4-C3" }

지퍼

지정된 함수를 두 시퀀스의 해당 요소에 적용하여 일련의 결과를 생성합니다.

var numbers = new [] { 1, 2, 3, 4, 5, 6 };
var words = new [] { "one", "two", "three" };

var numbersWithWords =
    numbers
    .Zip(
        words,
        (number, word) => new { number, word });

// Results

//| number | word   |
//| ------ | ------ |
//| 1      |  one   |
//| 2      |  two   |
//| 3      |  three |

투영 작업

투영은 객체를 새로운 형식으로 변환하는 작업을 나타냅니다.

고르다

변환 함수를 기반으로하는 값을 프로젝트합니다.

메서드 구문

// Select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = numbers.Select(n => n.ToString());

// strings = { "1", "2", "3", "4", "5" }

검색어 구문

// select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = from n in numbers
              select n.ToString();

// strings = { "1", "2", "3", "4", "5" }

SelectMany

변환 함수를 기반으로하는 값의 시퀀스를 투영 한 다음 하나의 시퀀스로 병합합니다.

메서드 구문

// SelectMany

class Customer
{
    public Order[] Orders { get; set; }
}

class Order
{
    public Order(string desc) { Description = desc; }
    public string Description { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Orders = new Order[] { new Order("O1"), new Order("O2") } },
    new Customer { Orders = new Order[] { new Order("O3") } },
    new Customer { Orders = new Order[] { new Order("O4") } },
};

var orders = customers.SelectMany(c => c.Orders);

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

검색어 구문

// multiples from

var orders = from c in customers
             from o in c.Orders
             select o;

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

정렬 작업

정렬 작업은 하나 이상의 속성을 기반으로 시퀀스의 요소를 정렬합니다.

주문

값을 오름차순으로 정렬합니다.

메서드 구문

// OrderBy

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderBy(n => n);

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

검색어 구문

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n
              select n;

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

OrderByDescending

값을 내림차순으로 정렬합니다.

메서드 구문

// OrderByDescending

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderByDescending(n => n);

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

검색어 구문

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n descending
              select n;

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

그 다음에

오름차순으로 2 차 정렬을 수행합니다.

메서드 구문

// ThenBy

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w.Length).ThenBy(w => w[0]);

// ordered = { "fox", "the", "brown", "jumps", "quick" }

검색어 구문

// orderby …, …

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0]
              select w;

// ordered = { "fox", "the", "brown", "jumps", "quick" }

그렇다면

내림차순으로 2 차 정렬을 수행합니다.

메서드 구문

// ThenByDescending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w[0]).ThenByDescending(w => w.Length);

// ordered = { "brown", "fox", "jumps", "quick", "the" }

검색어 구문

// orderby …, … descending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0] descending
              select w;

// ordered = { "the", "fox", "quick", "jumps", "brown" }

역

컬렉션의 요소 순서를 반대로 바꿉니다.

메서드 구문

// Reverse

var numbers = new int[] { 1, 2, 3, 4, 5 };

var reversed = numbers.Reverse();

// reversed = { 5, 4, 3, 2, 1 }

검색어 구문

// Not applicable.

변환 작업

변환 작업은 입력 개체의 유형을 변경합니다.

AsEnumerable

IEnumerable로 형식화 된 입력을 리턴합니다.

메서드 구문

// AsEnumerable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

검색어 구문

// Not applicable.

AsQueryable

IEnumerable을 IQueryable로 변환합니다.

메서드 구문

// AsQueryable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

검색어 구문

// Not applicable.

캐스트

컬렉션의 요소를 지정된 형식으로 캐스팅합니다.

메서드 구문

// Cast

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = numbers.Cast<int>();

// nums: static type is IEnumerable<int>

검색어 구문

// Use an explicitly typed range variable.

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = from int n in numbers select n;

// nums: static type is IEnumerable<int>

OfType

지정된 유형으로 형변환 할 수 있는지 여부에 따라 값을 필터링합니다.

메서드 구문

// OfType

var objects = new object[] { 1, "one", 2, "two", 3, "three" };

var numbers = objects.OfType<int>();

// nums = { 1, 2, 3 }

검색어 구문

// Not applicable.

ToArray

컬렉션을 배열로 변환합니다.

메서드 구문

// ToArray

var numbers = Enumerable.Range(1, 5);

int[] array = numbers.ToArray();

// array = { 1, 2, 3, 4, 5 }

검색어 구문

// Not applicable.

ToList

컬렉션을 목록으로 변환합니다.

메서드 구문

// ToList

var numbers = Enumerable.Range(1, 5);

List<int> list = numbers.ToList();

// list = { 1, 2, 3, 4, 5 }

검색어 구문

// Not applicable.

ToDictionary

키 선택기 기능을 기반으로 요소를 사전에 넣습니다.

메서드 구문

// ToDictionary

var numbers = new int[] { 1, 2, 3 };

var dict = numbers.ToDictionary(n => n.ToString());

// dict = { "1" => 1, "2" => 2, "3" => 3 }

검색어 구문

// Not applicable.

집계 작업

집계 연산은 값 모음에서 단일 값을 계산합니다.

골재

컬렉션 값에 대해 사용자 지정 집계 작업을 수행합니다.

메서드 구문

// Aggregate

var numbers = new int[] { 1, 2, 3, 4, 5 };

var product = numbers.Aggregate(1, (acc, n) => acc * n);

// product = 120

검색어 구문

// Not applicable.

평균

값 컬렉션의 평균값을 계산합니다.

메서드 구문

// Average

var numbers = new int[] { 1, 2, 3, 4, 5 };

var average = numbers.Average();

// average = 3

검색어 구문

// Not applicable.

카운트

컬렉션의 요소를 계산합니다. 선택적으로 조건부 함수를 만족하는 요소 만 계산합니다.

메서드 구문

// Count

var numbers = new int[] { 1, 2, 3, 4, 5 };

int count = numbers.Count(n => n % 2 == 0);

// count = 2

검색어 구문

// Not applicable.

LongCount

큰 컬렉션의 요소를 계산하고 선택적으로 조건부 함수를 만족하는 요소 만 계산합니다.

메서드 구문

// LongCount

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

long count = numbers.LongCount();

// count = 10

검색어 구문

// Not applicable.

맥스

컬렉션의 최대 값을 결정합니다. 콜렉션이 하늘의 경우는 예외를 슬로우합니다.

메서드 구문

// Max

var numbers = new int[] { 1, 2, 3, 4, 5 };

var max = numbers.Max();

// max = 5

검색어 구문

// Not applicable.

최소

컬렉션의 최소값을 결정합니다. 콜렉션이 하늘의 경우는 예외를 슬로우합니다.

메서드 구문

// Min

var numbers = new int[] { 1, 2, 3, 4, 5 };

var min = numbers.Min();

// min = 1

검색어 구문

// Not applicable.

Min / MaxOrDefault

다른 LinQ 확장과 달리 Min() 및 Max() 는 예외없이 과부하가 없습니다. 그러므로 IEnumerable 은 Min() 또는 Max() 호출하기 전에 Any() 를 검사해야합니다.

// Max

var numbers = new int[] { };

var max = numbers.Any() ? numbers.Max() : 0;

// max = 0

합집합

컬렉션의 값의 합을 계산합니다.

메서드 구문

// Sum

var numbers = new int[] { 1, 2, 3, 4, 5 };

var sum = numbers.Sum();

// sum = 15

검색어 구문

// Not applicable.

수량화 연산

수량 자 연산은 시퀀스의 일부 또는 모든 요소가 조건을 충족하는지 여부를 나타내는 부울 값을 반환합니다.

모든

시퀀스의 모든 요소가 조건을 충족하는지 여부를 결정합니다.

메서드 구문

// All

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool areLessThan10 = numbers.All(n => n < 10);

// areLessThan10 = true

검색어 구문

// Not applicable.

어떤

시퀀스의 요소가 조건을 충족하는지 여부를 결정합니다.

메서드 구문

// Any

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool anyOneIsEven = numbers.Any(n => n % 2 == 0);

// anyOneIsEven = true

검색어 구문

// Not applicable.

내용

시퀀스에 지정된 요소가 포함되는지 여부를 결정합니다.

메서드 구문

// Contains

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool appears = numbers.Contains(10);

// appears = false

검색어 구문

// Not applicable.

그룹화 작업

그룹화는 각 그룹의 요소가 공통 속성을 공유하도록 데이터를 그룹에 넣는 작업을 말합니다.

GroupBy

공통 속성을 공유하는 요소를 그룹화합니다.

메서드 구문

// GroupBy

class Order
{
    public string Customer { get; set; }
    public string Description { get; set; }
}
...

var orders = new Order[] 
{
    new Order { Customer = "C1", Description = "O1" },
    new Order { Customer = "C2", Description = "O2" },
    new Order { Customer = "C3", Description = "O3" },
    new Order { Customer = "C1", Description = "O4" },
    new Order { Customer = "C1", Description = "O5" },
    new Order { Customer = "C3", Description = "O6" },
};

var groups = orders.GroupBy(o => o.Customer);

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

검색어 구문

// group … by

var groups = from o in orders
             group o by o.Customer;

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

찾아보다

키 선택기 기능을 기반으로 일대 다 사전에 요소를 삽입합니다.

메서드 구문

// ToLookUp

var ordersByCustomer = orders.ToLookup(o => o.Customer);

// ordersByCustomer = ILookUp<string, Order>
// {
//     "C1" => { Order("01"), Order("04"), Order("05") },
//     "C2" => { Order("02") },
//     "C3" => { Order("03"), Order("06") }
// }

검색어 구문

// Not applicable.

파티션 작업

파티셔닝은 입력 시퀀스를 두 개의 섹션으로 나누고 요소를 재정렬하지 않고 섹션 중 하나를 반환하는 작업을 의미합니다.

버킷

시퀀스의 지정된 위치까지 요소를 건너 뜁니다.

메서드 구문

// Skip

var numbers = new int[] { 1, 2, 3, 4, 5 };

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

검색어 구문

// Not applicable.

SkipWhile

요소가 조건을 만족하지 않을 때까지 술어 함수를 기반으로 요소를 건너 뜁니다.

메서드 구문

// Skip

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var skipLeadingOdds = numbers.SkipWhile(n => n % 2 != 0);

// skipLeadingOdds = { 2, 1, 3, 5 }

검색어 구문

// Not applicable.

갖다

시퀀스의 지정된 위치까지 요소를 가져옵니다.

메서드 구문

// Take

var numbers = new int[] { 1, 2, 3, 4, 5 };

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

검색어 구문

// Not applicable.

TakeWhile

요소가 조건을 만족하지 않을 때까지 술어 함수를 기반으로 요소를 가져옵니다.

메서드 구문

// TakeWhile

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var takeLeadingOdds = numbers.TakeWhile(n => n % 2 != 0);

// takeLeadingOdds = { 1, 3, 5 }

검색어 구문

// Not applicable.

생성 작업

생성은 새로운 값 순서를 만드는 것을 가리 킵니다.

DefaultIfEmpty

빈 컬렉션을 기본 값 단일 컬렉션으로 바꿉니다.

메서드 구문

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

검색어 구문

// Not applicable.

빈

하늘의 콜렉션을 돌려줍니다.

메서드 구문

// Empty

var empty = Enumerable.Empty<string>();

// empty = IEnumerable<string> { }

검색어 구문

// Not applicable.

범위

일련의 숫자를 포함하는 모음을 생성합니다.

메서드 구문

// Range

var range = Enumerable.Range(1, 5);

// range = { 1, 2, 3, 4, 5 }

검색어 구문

// Not applicable.

반복

하나의 반복되는 값을 포함하는 컬렉션을 생성합니다.

메서드 구문

// Repeat

var repeats = Enumerable.Repeat("s", 3);

// repeats = { "s", "s", "s" }

검색어 구문

// Not applicable.

작업 설정

집합 연산은 동일하거나 별도의 집합 (또는 집합) 내의 동등한 요소의 유무에 기반한 결과 집합을 생성하는 쿼리 연산을 나타냅니다.

뚜렷한

컬렉션에서 중복 값을 제거합니다.

메서드 구문

// Distinct

var numbers = new int[] { 1, 2, 3, 1, 2, 3 };

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

검색어 구문

// Not applicable.

외

세트의 차이를 돌려줍니다. 이것은, 2 번째의 콜렉션에없는 1 개의 콜렉션의 요소를 나타냅니다.

메서드 구문

// Except

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var except = numbers1.Except(numbers2);

// except = { 1, 2, 3 }

검색어 구문

// Not applicable.

교차

두 개의 컬렉션 각각에 나타나는 요소를 의미하는 교차 집합을 반환합니다.

메서드 구문

// Intersect

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var intersect = numbers1.Intersect(numbers2);

// intersect = { 4, 5 }

검색어 구문

// Not applicable.

노동 조합

두 집합 중 하나에 나타나는 고유 한 요소를 나타내는 집합 통합을 반환합니다.

메서드 구문

// Union

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var union = numbers1.Union(numbers2);

// union = { 1, 2, 3, 4, 5, 6, 7, 8 }

검색어 구문

// Not applicable.

평등 운영

해당 요소가 같고 요소 수가 동일한 두 시퀀스가 ​​동일한 것으로 간주됩니다.

SequenceEqual

쌍을 이루어 요소를 비교하여 두 시퀀스가 ​​같은지 여부를 결정합니다.

메서드 구문

// SequenceEqual

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 1, 2, 3, 4, 5 };

var equals = numbers1.SequenceEqual(numbers2);

// equals = true

검색어 구문

// Not Applicable.

요소 조작

요소 작업은 시퀀스에서 하나의 특정 요소를 반환합니다.

요소

컬렉션의 지정된 인덱스에있는 요소를 반환합니다.

메서드 구문

// ElementAt

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAt(2);

// str = "two"

검색어 구문

// Not Applicable.

ElementAtOrDefault

콜렉션 내의 지정된 인덱스의 요소를 돌려줍니다. 인덱스가 범위 외의 경우는 디폴트 값을 돌려줍니다.

메서드 구문

// ElementAtOrDefault

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAtOrDefault(10);

// str = null

검색어 구문

// Not Applicable.

먼저

컬렉션의 첫 번째 요소 또는 조건을 충족하는 첫 번째 요소를 반환합니다.

메서드 구문

// First

var numbers = new int[] { 1, 2, 3, 4, 5 };

var first = strings.First();

// first = 1

검색어 구문

// Not Applicable.

FirstOrDefault

컬렉션의 첫 번째 요소 또는 조건을 충족하는 첫 번째 요소를 반환합니다. 해당 요소가 없으면 기본값을 반환합니다.

메서드 구문

// FirstOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var firstGreaterThanTen = strings.FirstOrDefault(n => n > 10);

// firstGreaterThanTen = 0

검색어 구문

// Not Applicable.

마지막

컬렉션의 마지막 요소 또는 조건을 만족하는 마지막 요소를 반환합니다.

메서드 구문

// Last

var numbers = new int[] { 1, 2, 3, 4, 5 };

var last = strings.Last();

// last = 5

검색어 구문

// Not Applicable.

LastOrDefault

컬렉션의 마지막 요소 또는 조건을 만족하는 마지막 요소를 반환합니다. 해당 요소가 없으면 기본값을 반환합니다.

메서드 구문

// LastOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var lastGreaterThanTen = strings.LastOrDefault(n => n > 10);

// lastGreaterThanTen = 0

검색어 구문

// Not Applicable.

단일

컬렉션의 유일한 요소 또는 조건을 만족하는 유일한 요소를 반환합니다.

메서드 구문

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

검색어 구문

// Not Applicable.

SingleOrDefault

컬렉션의 유일한 요소 또는 조건을 만족하는 유일한 요소를 반환합니다. 해당 요소가 없거나 콜렉션에 정확히 하나의 요소가없는 경우 기본값을 반환합니다.

메서드 구문

// SingleOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var singleGreaterThanFour = strings.SingleOrDefault(n => n > 4);

// singleGreaterThanFour = 5

검색어 구문

// Not Applicable.