42. LINQ 세부 문법

두 개의 from 절을 이용한 LINQ 문

using System.Collections;



namespace LINQEx
{
    class MemberScore
    {
        public string Name { get; set; }
        public int[] Score { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MemberScore[] ms =
            {
                new MemberScore(){Name="홍길동",Score=new int[]{30, 42, 67 } },
                new MemberScore(){Name="청길동",Score=new int[]{88, 45, 87 } },
                new MemberScore(){Name="녹길동",Score=new int[]{55, 66, 77 } },
                new MemberScore(){Name="흑길동",Score=new int[]{90, 80, 70 } },
                new MemberScore(){Name="백길동",Score=new int[]{99, 88, 30 } }
            };

            var members = from m in ms
                          from s in m.Score
                          where s < 60
                          orderby s, m.Name
                          select new {m.Name, FScore = s};

            foreach (var m in members)
            {
                Console.WriteLine($"이름 : {m.Name} F학점 성적 : {m.FScore}");
            }
        }
    }
}

Output

이름 : 백길동 F학점 성적 : 30
이름 : 홍길동 F학점 성적 : 30
이름 : 홍길동 F학점 성적 : 42
이름 : 청길동 F학점 성적 : 45
이름 : 녹길동 F학점 성적 : 55

• LINQ 문 내 두번째 from절 from s in m.Score 동작은 각 인스턴스 별 Score배열내에서 한개의 점수씩 확인을 진행함.

Group By 절

group by 형식

group X by Y into Z
X는 from 절에서 가져온 범위변수
Y는 분류기준
Z는 그룹변수

Group By 절 사용예제 코드

using System.Collections;

namespace LINQEx
{
    class Member
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Member[] m =
            {
                new Member(){Name = "강호동", Age = 42},
                new Member(){Name = "손흥민", Age = 31},
                new Member(){Name = "김연아", Age = 22},
                new Member(){Name = "장미란", Age = 35},
                new Member(){Name = "이만기", Age = 49}
            };

            var Group = from member in m
                        group member by member.Age > 35 into OB
                        select new { groupkey = OB.Key, members = OB };

            foreach (var member in Group)
            {
                if(member.groupkey)
                {
                    Console.WriteLine("<35세 초과 멤버>");
                    foreach(var member2 in member.members)
                    {
                        Console.WriteLine($"이름 : {member2.Name} 나이 : {member2.Age}");
                    }
                }
                else
                {
                    Console.WriteLine("<35세 이하 멤버>");
                    foreach (var member2 in member.members)
                    {
                        Console.WriteLine($"이름 : {member2.Name} 나이 : {member2.Age}");
                    }
                }
            }
        }
    }
}

Output

<35세 초과 멤버>
이름 : 강호동 나이 : 42
이름 : 이만기 나이 : 49
<35세 이하 멤버>
이름 : 손흥민 나이 : 31
이름 : 김연아 나이 : 22
이름 : 장미란 나이 : 35

[해당 예제코드 LINQ 구문]

var Group = from member in m
    group member by member.Age > 35 into OB
    select new { groupkey = OB.Key, members = OB };

• 35세 초과인 경우를 OB로 그룹핑을 진행.
• OB에 포함된 데이터들의 groupkey = true 로 저장. false 인경우에는 35세이하인 인스턴스들이 저장됨.
• 이때 member 에는 각각의 인스턴스들이 할당됨. (변수처럼 저장되어 사용할 수 있는 형태가 아님 = LINQ문 내에서만 유효)

key	data
true	{Name = "강호동", Age = 42}, {Name = "이만기", Age = 49}
false	{Name = "손흥민", Age = 31}, {Name = "김연아", Age = 22},{Name = "장미란", Age = 35}

조인(Join)

• 조인(join) : 서로 다른 두개의 데이터를 합치는 것, 완전히 다른것은 아니고 일치하는 부분에 대해서 합침
  - `내부조인(inner join)` : 두 데이터의 일치하는 데이터들만 합쳐서 반환하는 것.
  - `외부조인(outer join)` : 기본적으로 내부 조인과 비슷하지만, 조건이 일치하지 않더라도 기준데이터를 하나도 누락시키지 않고, 그대로 추출하여 빈 데이터를 채워서 통합하는 방식 - 외부조인에서 기준데이터가 어떤것이냐에 따라 덧붙는 데이터가 달라짐. - 기준데이터의 남은 일치하지 않은 데이터와 일치하는 데이터를 반환하는것. - 여기서 나온 개념이 `왼쪽조인(left join)`, `오른쪽조인(right join)`, `완전조인(full-outer join)`이다.

• LINQ에서는 왼쪽 조인(left join)만을 지원하고, 왠만해서는 왼쪽조인만으로 해결가능하다.

조인(join) 선언 형식

    from a in A // 기준데이터 
    join b in B on a.xxx equals b.xxx // 조인데이터 및 조인선언

내부조인(Inner Join) 사용 코드 예제

using System.Collections;

namespace LINQEx
{

    class Student
    {
        public string name { get; set; }
        public int age { get; set; }
    }

    class Score
    {
        public string name { get; set; }
        public int math { get; set; }
        public int english { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student[] studentList =
            {
                new Student(){name = "김말똥", age = 21},
                new Student(){name = "나말똥", age = 22},
                new Student(){name = "박말똥", age = 23},
                new Student(){name = "이말똥", age = 24},
                new Student(){name = "최말똥", age = 25},
            };

            Score[] scoreList =
            {
                new Score(){name = "김말똥", math = 98, english =77},
                new Score(){name = "나말똥", math = 88, english =66},
                new Score(){name = "강말똥", math = 69, english =99},
                new Score(){name = "이말똥", math = 79, english =88},
                new Score(){name = "오말똥", math = 54, english =55},
            };

            var Students = from student in studentList
                           join score in scoreList on student.name equals score.name
                           select new
                           {
                               Name = student.name,
                               Age = student.age,
                               Math = score.math,
                               English = score.english,
                           };

            foreach (var s in Students)
            {
                Console.WriteLine($"이름 : {s.Name}, 나이 : {s.Age}세, 수학 : {s.Math}점, 영어 : {s.English}점");
            }
        }
    }
}

Output

이름 : 김말똥, 나이 : 21세, 수학 : 98점, 영어 : 77점
이름 : 나말똥, 나이 : 22세, 수학 : 88점, 영어 : 66점
이름 : 이말똥, 나이 : 24세, 수학 : 79점, 영어 : 88점

• Student 인스턴스와 Score 인스턴스 데이터 내 일치하는 이름이 김말똥, 나말똥, 이말똥인것을 확인할 수 있다.
• 기준데이터는 Student 인스턴스 내 데이터로 하였으며, 내부조인 이므로 일치하는 데이터만을 반환한다.

외부조인(Outer Join)

외부조인 형식

    from a in A
    join b in B on a.xxx equals b.xxx into temp 
    // 여기까지는 내부조인과 비슷한 동작을해서 반환결과를 temp에 저장
    from b in temp.DefaultEmpty(new B() {empty = ""})
    // temp에서 비어있는 데이터를 가져와 b에서의 속성값으로 새로운 객체를 통해 생성.

외부조인(Outer Join) 사용 코드 예제

using System.Collections;

namespace LINQEx
{

    class Student
    {
        public string name { get; set; }
        public int age { get; set; }
    }

    class Score
    {
        public string name { get; set; }
        public int math { get; set; }
        public int english { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student[] studentList =
            {
                new Student(){name = "김말똥", age = 21},
                new Student(){name = "나말똥", age = 22},
                new Student(){name = "박말똥", age = 23},
                new Student(){name = "이말똥", age = 24},
                new Student(){name = "최말똥", age = 25},
            };

            Score[] scoreList =
            {
                new Score(){name = "김말똥", math = 98, english =77},
                new Score(){name = "나말똥", math = 88, english =66},
                new Score(){name = "강말똥", math = 69, english =99},
                new Score(){name = "이말똥", math = 79, english =88},
                new Score(){name = "오말똥", math = 54, english =55},
            };

            var Students = from student in studentList
                           join score in scoreList on student.name equals score.name into temp
                           from score in temp.DefaultIfEmpty(new Score() { math = 100, english = 100 })
                           select new
                           {
                               name = student.name,
                               age = student.age,
                               math = score.math,
                               english = score.english,
                           };

            foreach (var student in Students)
            {
                Console.WriteLine(student);
            }
        }
    }
}

Output

{ name = 김말똥, age = 21, math = 98, english = 77 }
{ name = 나말똥, age = 22, math = 88, english = 66 }
{ name = 박말똥, age = 23, math = 100, english = 100 }
{ name = 이말똥, age = 24, math = 79, english = 88 }
{ name = 최말똥, age = 25, math = 100, english = 100 }