C# LINQ: Where, Select, OrderBy, GroupBy 사용법과 예제

LINQ(Language Integrated Query)는 시퀀스를 필터링, 변환, 정렬, 그룹화, 요약하는 메서드 라이브러리입니다. using System.Linq;를 추가하면 모든 배열, List<T>, Dictionary와 그 밖의 IEnumerable<T>에 Where, Select, OrderBy 같은 메서드가 생기며, 각각 요소 하나로 무엇을 할지 말해 주는 람다를 받습니다.

첫 쿼리: 메서드 구문과 쿼리 구문

LINQ에는 두 가지 표기법이 있습니다. 메서드 구문은 호출을 연결하고, 쿼리 구문은 SQL처럼 읽힙니다. 컴파일러가 쿼리 구문을 같은 메서드 호출로 바꾸므로 결과는 똑같습니다.

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

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79, 91 };

        // Method syntax
        IEnumerable<int> high = scores
            .Where(s => s >= 80)
            .OrderByDescending(s => s);

        // Query syntax: the same query
        IEnumerable<int> high2 =
            from s in scores
            where s >= 80
            orderby s descending
            select s;

        Console.WriteLine(string.Join(", ", high));
        Console.WriteLine(string.Join(", ", high2));
    }
}

출력:

95, 91, 88
95, 91, 88

최신 코드에서는 메서드 구문이 더 흔하고, 일부 연산자(Take, Distinct, Count, First, ToList)는 메서드로만 존재합니다. 쿼리 구문은 조인과 let으로 중간 변수를 도입하는 쿼리에서 빛납니다. 이 페이지의 나머지는 메서드 구문을 쓰고, 쿼리 구문이 보탬이 되는 곳에서만 보여 줍니다.

Where와 Select: 필터링과 투영

Where는 조건에 맞는 요소를 남깁니다. Select는 각 요소를 다른 것으로 바꿉니다. 둘을 함께 쓰면 일상적인 쿼리 대부분이 해결됩니다.

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

class Product
{
    public string Name;
    public string Category;
    public decimal Price;
    public Product(string n, string c, decimal p) { Name = n; Category = c; Price = p; }
}

class Program
{
    static void Main()
    {
        var products = new List<Product>
        {
            new Product("Mug", "Kitchen", 8.50m),
            new Product("Lamp", "Home", 32.00m),
            new Product("Kettle", "Kitchen", 27.00m),
            new Product("Rug", "Home", 120.00m),
        };

        IEnumerable<string> cheapNames = products
            .Where(p => p.Price < 30m)
            .Select(p => p.Name);
        Console.WriteLine(string.Join(", ", cheapNames));

        var labels = products.Select(p => p.Name.ToUpper() + " $" + p.Price);
        Console.WriteLine(string.Join(" | ", labels));

        // An anonymous type holds a few properties without declaring a class.
        var summary = products
            .Where(p => p.Category == "Home")
            .Select(p => new { p.Name, WithTax = Math.Round(p.Price * 1.2m, 2) });
        foreach (var item in summary)
        {
            Console.WriteLine(item.Name + ": " + item.WithTax);
        }

        // Select also has an overload with the index.
        var numbered = products.Select((p, i) => (i + 1) + ". " + p.Name);
        Console.WriteLine(string.Join(" ", numbered));
    }
}

출력:

Mug, Kettle
MUG $8.50 | LAMP $32.00 | KETTLE $27.00 | RUG $120.00
Lamp: 38.40
Rug: 144.00
1. Mug 2. Lamp 3. Kettle 4. Rug

Where는 요소를 절대 바꾸지 않고, Select는 개수를 절대 바꾸지 않습니다. new { p.Name, WithTax = ... }는 익명 형식, 즉 컴파일러가 대신 작성해 주는 클래스를 만들며, 그 속성은 일반 점 문법으로 읽습니다. 쓸 수 있는 이름이 없으므로 이를 담는 변수는 var로 선언해야 하고, 한 메서드 안에 머무는 결과에 어울립니다.

OrderBy, ThenBy와 여러 키로 정렬하기

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

class Program
{
    static void Main()
    {
        var orders = new List<(string Customer, decimal Total)>
        {
            ("Ben", 40m), ("Ana", 15m), ("Ben", 90m), ("Ana", 60m), ("Chloe", 25m),
        };

        var sorted = orders
            .OrderBy(o => o.Customer)            // first key
            .ThenByDescending(o => o.Total);     // tie breaker
        foreach (var o in sorted)
        {
            Console.WriteLine(o.Customer + " " + o.Total);
        }

        var query =
            from o in orders
            orderby o.Total descending
            select o.Customer;
        Console.WriteLine(string.Join(", ", query));
    }
}

출력:

Ana 60
Ana 15
Ben 90
Ben 40
Chloe 25
Ben, Ana, Ben, Chloe, Ana

OrderBy는 안정 정렬입니다. 키가 같은 요소는 원래 순서를 유지합니다. 두 번째 키에는 ThenBy나 ThenByDescending을 쓰세요. 두 번째 OrderBy는 모든 것을 자기 키로 다시 정렬해서 첫 키를 단순한 동점 판정으로 만듭니다. 우선순위가 반대가 됩니다. 쿼리 구문에서는 키를 쉼표로 구분합니다: orderby o.Customer, o.Total descending.

List<T>.Sort와 달리 OrderBy는 원본을 그대로 두고 새 시퀀스를 반환합니다.

First, Single, Last와 OrDefault 버전

이들은 시퀀스 대신 요소 하나를 반환합니다. 일반 버전은 반환할 것이 없으면 예외를 던지고, OrDefault 버전은 타입의 기본값을 반환합니다.

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

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben", "Bea", "Chloe" };

        Console.WriteLine(names.First());
        Console.WriteLine(names.First(n => n.StartsWith("B")));
        Console.WriteLine(names.Last(n => n.StartsWith("B")));
        Console.WriteLine(names.FirstOrDefault(n => n.StartsWith("Z")) == null);

        try
        {
            names.First(n => n.StartsWith("Z"));
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("First: " + e.GetType().Name);
        }

        try
        {
            names.Single(n => n.StartsWith("B")); // two matches
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Single: " + e.GetType().Name);
        }

        int[] scores = { 72, 95 };
        Console.WriteLine(scores.FirstOrDefault(s => s > 100)); // 0, not "missing"
    }
}

출력:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

빈 시퀀스에서 First가 던지는 예외는 "Sequence contains no elements" 메시지(조건자에 일치하는 것이 없으면 "Sequence contains no matching element")를 가진 InvalidOperationException이며, 가장 많이 검색되는 C# 오류 중 하나입니다. "없음"이 정상적인 결과라면 FirstOrDefault를 쓰고 null을 확인하세요.

마지막 줄은 값 형식의 함정을 보여 줍니다. int 시퀀스에서 FirstOrDefault는 일치하는 것이 없으면 0을 반환하는데, 이는 진짜 0과 구분할 수 없습니다. Where로 필터링하고 먼저 Any()를 확인하거나, .NET 6 이상에서는 직접 기본값을 넘기세요: scores.FirstOrDefault(s => s > 100, -1).

Single은 "정확히 하나"를 위한 것입니다. 없거나 둘 이상이면 예외를 던지므로 쿼리이자 단언이기도 합니다.

Any, All, Count, Contains

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] ages = { 17, 22, 35, 41, 16 };

        Console.WriteLine(ages.Any());                 // is it non-empty?
        Console.WriteLine(ages.Any(a => a < 18));      // at least one minor?
        Console.WriteLine(ages.All(a => a >= 16));     // everyone 16 or older?
        Console.WriteLine(ages.Count(a => a >= 18));   // how many adults?
        Console.WriteLine(ages.Contains(35));

        int[] none = { };
        Console.WriteLine(none.All(a => a > 100));      // true for an empty sequence
    }
}

출력:

True
True
True
3
True
True

Any()는 첫 일치 항목에서 멈추므로 "뭐라도 있나?"를 묻는 올바른 방법은 items.Any()입니다. items.Count() > 0은 원본이 리스트나 배열 같은 컬렉션이면 Count 속성을 읽지만, 쿼리나 다른 지연 시퀀스에서는 먼저 모든 요소를 훑습니다. 빈 시퀀스에 대한 All은 조건을 실패하는 요소가 없으므로 true를 반환합니다.

Sum, Average, Min, Max

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

class Program
{
    static void Main()
    {
        var cart = new List<(string Item, decimal Price, int Qty)>
        {
            ("Tea", 4.50m, 2), ("Honey", 7.25m, 1), ("Cups", 3.00m, 4),
        };

        Console.WriteLine("Total: " + cart.Sum(c => c.Price * c.Qty));
        Console.WriteLine("Items: " + cart.Sum(c => c.Qty));
        Console.WriteLine("Priciest: " + cart.Max(c => c.Price));
        Console.WriteLine("Average price: " + cart.Average(c => c.Price).ToString("F2"));

        var empty = new List<int>();
        Console.WriteLine(empty.Sum());
        try
        {
            empty.Average();
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Average: " + e.GetType().Name);
        }
    }
}

출력:

Total: 28.25
Items: 7
Priciest: 7.25
Average price: 4.92
0
Average: InvalidOperationException

빈 시퀀스의 Sum은 0이지만, 빈 숫자 시퀀스의 Average, Min, Max는 합리적인 답이 없으므로 InvalidOperationException을 던집니다. Any()로 막거나 먼저 DefaultIfEmpty()를 쓰세요: empty.DefaultIfEmpty(0).Average().

Distinct, Take, Skip

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] visits = { "home", "shop", "home", "cart", "shop", "home" };
        Console.WriteLine(string.Join(", ", visits.Distinct()));

        int[] ids = Enumerable.Range(1, 23).ToArray(); // 1..23
        int pageSize = 10;
        for (int page = 0; page * pageSize < ids.Length; page++)
        {
            var items = ids.Skip(page * pageSize).Take(pageSize);
            Console.WriteLine("Page " + (page + 1) + ": " + string.Join(" ", items));
        }

        int[] temps = { 12, 15, 21, 24, 19, 11 };
        Console.WriteLine(string.Join(", ", temps.TakeWhile(t => t < 20)));
    }
}

출력:

home, shop, cart
Page 1: 1 2 3 4 5 6 7 8 9 10
Page 2: 11 12 13 14 15 16 17 18 19 20
Page 3: 21 22 23
12, 15

Distinct는 각 값의 첫 등장을 순서대로 남깁니다. Skip(n).Take(m)은 표준적인 페이지 나누기 패턴이고, TakeWhile/SkipWhile은 조건을 실패하는 첫 요소에서 멈추거나 시작합니다. Enumerable.Range(start, count)는 배열 없이 정수 시퀀스를 만듭니다.

GroupBy

GroupBy는 요소를 키에 따라 버킷에 나눠 담습니다. 각 그룹은 Key를 가지며 그 자체가 시퀀스이므로 집계할 수 있습니다.

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

class Program
{
    static void Main()
    {
        var sales = new List<(string Region, string Rep, int Amount)>
        {
            ("North", "Ana", 300), ("South", "Ben", 150), ("North", "Chloe", 200),
            ("East", "Dev", 350), ("South", "Eli", 250), ("North", "Ana", 100),
        };

        foreach (var g in sales.GroupBy(s => s.Region))
        {
            Console.WriteLine(g.Key + ": " + g.Count() + " sales, total " + g.Sum(s => s.Amount));
        }

        var top = sales
            .GroupBy(s => s.Rep)
            .Select(g => new { Rep = g.Key, Total = g.Sum(s => s.Amount) })
            .OrderByDescending(x => x.Total)
            .First();
        Console.WriteLine("Top rep: " + top.Rep + " " + top.Total);

        var byRegion =
            from s in sales
            group s.Rep by s.Region into g
            select g.Key + " -> " + string.Join("/", g);
        Console.WriteLine(string.Join("; ", byRegion));
    }
}

출력:

North: 3 sales, total 600
South: 2 sales, total 400
East: 1 sales, total 350
Top rep: Ana 400
North -> Ana/Chloe/Ana; South -> Ben/Eli; East -> Dev

그룹은 정렬된 순서가 아니라 키가 원본에 처음 나타나는 순서(North, South, East)로 나옵니다. 정렬이 필요하면 OrderBy(g => g.Key)를 추가하세요. 쿼리 구문에서 group X by K는 각 그룹에 무엇을 넣을지(여기서는 담당자 이름만) 고르고, into g는 쿼리를 이어 갈 수 있도록 그룹에 이름을 붙입니다.

ToList, ToArray, ToDictionary

To... 메서드는 쿼리를 실행하고 결과를 저장합니다.

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

class Program
{
    static void Main()
    {
        var users = new List<(int Id, string Email)>
        {
            (1, "ana@x.com"), (2, "ben@x.com"), (3, "cy@x.com"),
        };

        Dictionary<int, string> byId = users.ToDictionary(u => u.Id, u => u.Email);
        Console.WriteLine(byId[2]);

        var wordCounts = "to be or not to be".Split(' ')
            .GroupBy(w => w)
            .ToDictionary(g => g.Key, g => g.Count());
        Console.WriteLine(wordCounts["be"]);

        try
        {
            users.ToDictionary(u => u.Email.Length); // two emails of length 9
        }
        catch (ArgumentException e)
        {
            Console.WriteLine("ToDictionary: " + e.GetType().Name);
        }
    }
}

출력:

ben@x.com
2
ToDictionary: ArgumentException

두 요소가 같은 키를 만들면 ToDictionary는 Dictionary.Add와 똑같이 ArgumentException을 던집니다. 중복이 예상된다면 먼저 그룹화하거나(wordCounts처럼), 각 키를 값의 시퀀스에 대응시키는 ToLookup을 쓰세요.

지연 실행

Where, Select, OrderBy, GroupBy를 비롯한 대부분의 연산자는 쿼리 객체를 반환하고, 무언가가 이를 열거하기 전까지 아무 일도 하지 않습니다. 여기서 볼 만한 결과가 두 가지 나옵니다:

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

class Program
{
    static void Main()
    {
        var prices = new List<int> { 10, 25, 40 };

        IEnumerable<int> expensive = prices.Where(p => p > 20); // nothing runs yet
        prices.Add(99);                                        // added after the query
        Console.WriteLine(string.Join(", ", expensive));        // runs now, sees 99

        IEnumerable<int> logged = prices.Select(p =>
        {
            Console.WriteLine("  converting " + p);
            return p * 100;
        });

        Console.WriteLine("Count: " + logged.Count());          // runs the query once
        Console.WriteLine("Max: " + logged.Max());              // and again

        List<int> cached = logged.ToList();                     // run once, keep results
        Console.WriteLine("Cached: " + cached.Count + ", " + cached.Max());
    }
}

출력:

25, 40, 99
  converting 10
  converting 25
  converting 40
  converting 99
Count: 4
  converting 10
  converting 25
  converting 40
  converting 99
Max: 9900
  converting 10
  converting 25
  converting 40
  converting 99
Cached: 4, 9900

첫 쿼리는 쿼리를 작성한 뒤에 추가된 99를 보았습니다. 필터가 string.Join이 열거할 때 실행되었기 때문입니다. 두 번째 쿼리는 Count()와 Max()가 각각 처음부터 열거했으므로 변환을 두 번 출력했습니다. 가벼운 람다라면 작업 낭비일 뿐이지만, 람다 안에 데이터베이스 쿼리, 파일 읽기, 난수가 있다면 두 번의 순회가 서로 다른 데이터를 반환할 수 있습니다. 결과를 두 번 이상 쓸 것이라면 ToList()나 ToArray()로 구체화하세요.

값 하나를 반환하는 연산자(Count, Sum, First, Any, Max)와 To... 메서드는 즉시 실행됩니다. 이 지연성이 어떻게 만들어지는지는 IEnumerable과 yield를 참고하세요.

빠른 참조

흔한 실수

• 비어 있을 수 있는 시퀀스에 First() 쓰기. "Sequence contains no elements"를 던집니다. FirstOrDefault를 쓰고 확인하세요.
• OrderBy 두 번 호출하기. 두 번째 키가 주 키가 됩니다. ThenBy를 쓰세요.
• 쿼리를 여러 번 열거하기. 작업이 반복됩니다. ToList()를 한 번 호출하세요.
• 쿼리가 원본의 스냅샷을 찍으리라 기대하기. 작성할 때가 아니라 열거할 때 원본을 읽습니다.
• 빈 시퀀스에 Average, Min, Max 쓰기. 예외를 던집니다. Any()나 DefaultIfEmpty로 막으세요.
• 요소 확인에 Count() > 0 쓰기. Any()는 첫 요소에서 멈춥니다.