using System.Collections;
/*
[LINQ]
LINQ์ ์ง์ํํ์ = ์ฟผ๋ฆฌ ์ (Query Expression) ์ from ์ ๋ก ์์ํ๋ค.
- from ์ ๋ค์์๋ ๋ฐ์ดํฐ ์๋ณธ์ด ์จ๋ค. ๋ฐ์ดํฐ ์๋ณธ์ ๋ฐฐ์ด, ์ปฌ๋ ์
๋ฑ์ด ์ฌ ์ ์๋ค.
- from <๋ฒ์๋ณ์> in <๋ฐ์ดํฐ ์๋ณธ>
```csharp
int[] aaa = {11,22,33,44,55}
var res = from a in aaa
where a % 2 != 0
orderby a
select a;
```
- where ์ ์ ๋ฒ์ ๋ณ์์ ์กฐ๊ฑด์ ์ง์ ํ์ฌ ๊ทธ ์กฐ๊ฑด์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฑธ๋ฌ๋ด๋ ์ญํ ์ ํ๋ค.
- orderby์ ์ where ์ ์์ ๊ฑธ๋ฌ๋ธ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ ์ญํ ์ ํ๋ค.
- ๊ธฐ๋ณธ ์ ๋ ฌ๊ฐ์ ์ค๋ฆ์ฐจ์ ascending ์ผ๋ก ์ง์ ๋์ด ์๋ค. ๋ด๋ฆผ์ฐจ์์ descending
- select ์ ์ ์ง์(Query)์ ์ต์ข
๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์จ๋ค(์ถ์ถํ๋ค).
- ์ฟผ๋ฆฌ๋ฌธ์ ์ํด ์กฐํ๋ ๋ฐ์ดํฐ์ ํน์ ์์ฑ๊ฐ๋ง ๊ฐ์ ธ์ฌ ์ ๋ ์๋ค.
- ์ฟผ๋ฆฌ๋ฌธ์ ์ํด ๋ฐํ๋ ๋ฐ์ดํฐ ๋ชฉ๋ก์ IEnumerableํด๋์ค๋ฅผ ์์ํ๊ธฐ์ foreach๋ฌธ์ ์ด์ฉํด ์ํํ ์ ์๋ค.
*/
namespace LinqEx
{
class Member
{
public string name { get; set; }
public int age { get; set; }
}
class Program
{
static void Main(string[] args)
{
Member[] ml =
{
new Member(){name = "ํ๊ธธ๋" , age =23},
new Member(){name = "์ฒญ๊ธธ๋" , age =24},
new Member(){name = "๋ฐฑ๊ธธ๋" , age =27},
new Member(){name = "๋
น๊ธธ๋" , age =25},
new Member(){name = "๊ฒ๊ธธ๋" , age =26},
};
List<Member> list = new List<Member>();
foreach (Member m in ml)
{
if (m.age >= 25)
{
list.Add(m);
}
}
list.Sort(
(member1, member2) =>
{
return member2.age - member1.age;
}
);
foreach (Member m in list)
{
Console.WriteLine($"์ด๋ฆ : {m.name} ๋์ด : {m.age}");
}
// ์์ ์์
์ LINQ ํ์ฉ์.
Console.WriteLine();
Console.WriteLine("---------LINQํ์ฉ----------");
var ml2 = from member in ml
where member.age >= 25
orderby member.age
select new { member.name, age = member.age + "์ธ" };
foreach (var m in ml2)
{
Console.WriteLine($"์ด๋ฆ : {m.name} ๋์ด : {m.age}");
}
}
}
}
Output
์ด๋ฆ : ๋ฐฑ๊ธธ๋ ๋์ด : 27
์ด๋ฆ : ๊ฒ๊ธธ๋ ๋์ด : 26
์ด๋ฆ : ๋
น๊ธธ๋ ๋์ด : 25
---------LINQํ์ฉ----------
์ด๋ฆ : ๋
น๊ธธ๋ ๋์ด : 25์ธ
์ด๋ฆ : ๊ฒ๊ธธ๋ ๋์ด : 26์ธ
์ด๋ฆ : ๋ฐฑ๊ธธ๋ ๋์ด : 27์ธ
- 39์ฅ LINQ ์ฌ์ฉํด๋ณด๊ธฐ ์ฝ๋์ ๋น๊ต. =>
select
๋ถ๋ถ- ์ฟผ๋ฆฌ๋ฌธ์ ์ํด ์กฐํ๋ ๋ฐ์ดํฐ์ ํน์ ์์ฑ๊ฐ๋ง ๊ฐ์ ธ์ฌ ์ ๋ ์๋ค.
- ์ฟผ๋ฆฌ๋ฌธ์ ์ํด ๋ฐํ๋ ๋ฐ์ดํฐ ๋ชฉ๋ก์ IEnumerableํด๋์ค๋ฅผ ์์ํ๊ธฐ์ foreach๋ฌธ์ ์ด์ฉํด ์ํํ ์ ์๋ค.
#### [LINQ] ๊ธฐ๋ณธ ๋ฌธ๋ฒ
LINQ์ ์ง์ํํ์ = ์ฟผ๋ฆฌ ์ (Query Expression) ์ from ์ ๋ก ์์ํ๋ค.
from ์ ๋ค์์๋ ๋ฐ์ดํฐ ์๋ณธ์ด ์จ๋ค. ๋ฐ์ดํฐ ์๋ณธ์ ๋ฐฐ์ด, ์ปฌ๋ ์ ๋ฑ์ด ์ฌ ์ ์๋ค.
์ด๋ from์ ์์์ ๋งค๊ฐ๋ณ์๋
IEnumerable<T>
์ ํ์ํ์์ด์ด์ผ ํ๋ค.from <๋ฒ์๋ณ์> in <๋ฐ์ดํฐ ์๋ณธ>
int[] aaa = {11,22,33,44,55} var res = from a in aaa where a % 2 != 0 orderby a select a;
where
์ ์ ๋ฒ์ ๋ณ์์ ์กฐ๊ฑด์ ์ง์ ํ์ฌ ๊ทธ ์กฐ๊ฑด์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฑธ๋ฌ๋ด๋ ์ญํ ์ ํ๋ค.orderby
์ ์where
์ ์์ ๊ฑธ๋ฌ๋ธ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ ์ญํ ์ ํ๋ค.- ๊ธฐ๋ณธ ์ ๋ ฌ๊ฐ์ ์ค๋ฆ์ฐจ์
ascending
์ผ๋ก ์ง์ ๋์ด ์๋ค. ๋ด๋ฆผ์ฐจ์์descending
- ๊ธฐ๋ณธ ์ ๋ ฌ๊ฐ์ ์ค๋ฆ์ฐจ์
select
์ ์ ์ง์(Query)์ ์ต์ข ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์จ๋ค(์ถ์ถํ๋ค).- LINQ์์ ๋ฐํ๋๋ ๊ฒฐ๊ณผ
IEnumerable<T>
์ธ๋ฐ T๋select
์ ์์์ ๋ฐํ๊ฒฐ๊ณผ ํ์์ด๋ค. - ๋ง์ผ
select
์ ์ ์ฌ์ฉํ์ง ์์ผ๋ฉดwhere
์ ์ ์ํด ํํฐ๋ง๋ ์ปฌ๋ ์ ์๋ณธ์ด ๋์ค๊ฒ ๋๋ค. ์ด๋์ ํ์ ์IEnumerable<T>
์ด๋ฉฐ, ๋จ์ํ ์ํ๋ฅผ ํ๋ฉด์ ๊ฐ์ ์ฐธ์กฐํ ๊ฒ์ด๋ผ๋ฉด ๋ณํ์ด ํ์์์ง๋งList
ํน์Dictionary
๋ก ๋ณํํด์ผํ๋ค๋ฉดToList()
ํน์ToDictionary()
๋ฅผ ์ฌ์ฉํด ๋ณํํด์ค๋ค.
'๐ป Programming Language > C#' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
42. LINQ ์ธ๋ถ ๋ฌธ๋ฒ (0) | 2022.04.08 |
---|---|
41. ์ต๋ช Type (0) | 2022.04.08 |
39. LINQ ์ฌ์ฉํด๋ณด๊ธฐ (0) | 2022.04.08 |
38. ๋๋ค์(Lambda Expression) (0) | 2022.04.08 |
37. ๋ธ๋ฆฌ๊ฒ์ดํธ๋ฅผ ํตํ ์ด๋ฒคํธ ์ฒ๋ฆฌ (0) | 2022.04.08 |