CLIEL LAB

[C# 14 / .NET 10] 흐름제어, Type 변환, 예외 처리

클리엘 — Thu, 12 Feb 2026 16:21:00 +0900

# 14에 대한 3번째 순서에서는 변수와 array를 통한 data다루기와 함께, 의사결정/반복수행과 같은 실제 program의 동작방식을 살펴보고, 서로 다른 type간 형변환과 예외처리를 포함하여 application작성에 관한 전반적인 사항을 알아보고자 합니다.

1. 연산자

연산자라함은 실제값 또는 피연산자를 대상으로 사칙연산과 같은 동작을 수행하도록 하는 것을 말합니다. 이때 연산자는 연산결과에 대한 값을 반환할 수 있고 이 값은 다시 다른 변수에 할당할 수 있습니다.

1) 산술연산자

(1) 이항(binary) 연산자

가장 보편적인 연산자이며 2개의 피연산자를 필요로 합니다.

var resultVariable = firstVariable [연산자] secodVariable;

아래 예제는 이항연산자의 일반적인 사용방법을 나타내고 있습니다.

int x = 10;
int y = 20;

int resultAdd = x + y;
int resultMultiple = x * y;

가장 일반적인 이항연산자는 +, -, *, / 정도로 볼 수 있고 다른 하나는 % 인데 이는 나머지로 생각할 수 있습니다.

int i = 10;
int j = 3;

Console.WriteLine($"{i % j}"); //결과 1

(2) 단항(unary) 연산자

단항 연산자는 하나의 피연산자를 필요로 하는 것으로 피연산자의 앞이나 뒤에서 연산을 수행할 수 있습니다. 단항 연산자를 사용하는 가장 대표적인 사례로 증감/감소연산자를 예로 들 수 있습니다.

int i = 10;
int a = ++i;
int b = i++;

또한 typeof나 nameof, sizeof도 단한 연산자에 해당할 수 있습니다.

Type resultType = typeof(int);
string resultName = nameof(i);
int resultByteSize = sizeof(int);

++와 --에서 ++는 1씩 증가시키는 증감연산자, --를 1씩 감소시키는 감소연산자라고 합니다.

int i = 10;
int j = i++;

Console.WriteLine($"{i} / {j}");

위 예제는 증감연산자를 사용하여 변수 i의 값을 1만큼 증기시키고 있습니다. 위 예제를 실행하면 결과값으로 '11 / 10'을 나타내게 됩니다.

++는 1만큼 증가시킨다고 했는데 왜 결과에서 j의 값이 10이라고 할까? 그 이유는 ++연산자가 i의 값을 j에 할당하고 난 뒤에 실행되었기 때문입니다. 이런것을 후위연산자라고 하며 만약 i변수의 값이 j에 할당되기 전에 먼저 ++가 실행되어야 한다면 이를 '++i'와 같이 변수앞에 단항연산자를 붙여줘야 하고 이를 선행연산자라고 합니다.

int i = 10;
int j = ++i;

Console.WriteLine($"{i} / {j}");

위 예제는 ++를 선행연산자로 적용한 것이며 예제를 실행하면 '11 / 11'이라는 결과를 표시할 것입니다.

증감, 감소연산자를 할당연산자와 결합하여 사용할때 자칫 code를 읽는데서 잘못된 예상결과의 판단을 불러올 수 있습니다. 이러한 우려 때문에 Swift언어의 경우 version 3부터 단항연산자를 지원하지 않기도 합니다. 따라서 증감, 감소연산자를 사용하더라도 되도록이면 할당연산자와 결합하는 것을 피하는 것이 좋습니다.

(3) 삼항(ternary) 연산자

삼항 연산자는 아래와 같이 3개의 피연산자를 필요로 합니다.

var result = first ? second : third

위 예시에서는 삼항 연산자의 가장 흔한 것으로 if문과 유사한 '?:'를 사용하는 조건부 연산자를 나타내고 있습니다. 여기서 first는 boolean값을 표현하는 피연산자가 와야하며 second는 first가 true인 경우 반환할 값을, third는 first가 false인 경우 반환할 값을 나타냅니다.

int i = 10;

string result = i > 10 ? "i는 10보다 큽니다." : "i는 10과 같거나 작습니다.";

Console.WriteLine(result);

상기 예제는 실제 삼항연산자를 사용해 조건부 연산을 수행한 것으로 이것을 if문으로 바꿔보면 다음과 같이 구현할 수 있습니다.

if (i > 10)
{
    result = "i는 10보다 큽니다.";
}
else
{
    result = "i는 10과 같거나 작습니다.";
}

실제 많은 C#개발자가 가능한 경우 if문을 사용하기 보다는 삼항연산자를 사용하는 경우가 많습니다. Code를 더욱 간소화할 수 있고 읽기에도 익숙해진다면 더 명확한 code가 될 수 있기 때문입니다.

(4) 할당 연산자

지금까지의 예제를 통해 사용되어온 '='문자가 바로 할당연산자입니다. 할당연산자는 다른연산자와 결합이 가능하므로 아래와 같이 code를 간소화하여 사용하는 경우도 있습니다.

int i = 1;
i += 1 // i = i + 1;
i -= 1 // i = i - 1;
i *= 1 // i = i * 1;
i /= 1 // i = i / 1;

2) NULL 연산자

할당계열의 연산자로서 기본적으로 값을 활당하지만 만약 값이 null인 경우 이를 대체하는 다른 값으로 대신 할당하도록 하는 연산자입니다.

NULL 병합 연산자는 아래와 같이 3가지를 사용할 수 있습니다.

연산자	명칭	역활
?.	Null 조건부 연산자 (Null-conditional)	개체가 null이라면 null을 반환하며 그렇지 않으면 개체를 통해 지정한 해당 속성의 값을 대신 반환합니다.
??	Null 병합 연산자 (Null-coalescing)	왼쪽 표현식이 null이라면 오른쪽 값을 반환하지만 그렇지 않으면 아무것도 동작도 수행하지 않습니다.
??=	Null 병합 할당 연산자 (Null-coalescing assignment)	왼쪽 표현식이 null이라면 오른쪽 값을 반환하지만 그렇지 않으면 아무것도 동작도 수행하지 않습니다. 단순히 표현식을 평가하는 ??과는 달리 '??='연산자는 변수가 null인 경우 즉각 값을 할당합니다.

아래 예제에서는 위 연산자에 대한 사용방식을 간단히 표현하고 있습니다.

int age = Employee?.Age ?? 0;
EmployeeName ??= "unknown";

예제에서 첫번째 구문의 '?.'연산자는 Age속성의 값을 할당하기 전에 Employee가 null인지를 우선 확안하게 됩니다. 만약 Employee가 null이라면 null자체를 반환하게 되고 그 상태에서 ?? 연산자를 통해 null이 확인되어 0을 할당하게 됩니다. 만약 Employee가 null이 아니라면 그때는 Employee?.Age값을 할당할 것입니다.

두번째 구문은 EmployeeName이 null이라면 '??='연산자에 의해 여기에 "unknown"이라는 문자열값을 할당합니다.

위와 같은 null연산자는 null이 발생하는 경우 null에 대한 예외를 일으키는 대신 대안으로 제시한 값을 대신 할당하게 함으로서 code를 간소하고 효휼적으로 작성할 수 있도록 해줍니다. 만약 위와 같은 null 연산자를 사용하지 않는다면 우리는 아래와 같이 null에 대한 예외사항을 직접 작성해줘야 합니다.

int age;
if (Employee is not null)
{
    age = Employee.Age;    
}
else
{
    age = 0;
}

(1) NULL 조건부 할당 연산자 (Null-conditional assignment operator)

C# 14 부터 Null 조건부 할당 연산자는 instance를 포함하는 경우에만 속성이나 field에 값을 할당할 수 있습니다. 예를 들어 Employee라는 class와 함께

public class Employee
{
    public string Name { get; set; } = string.Empty;
    public int Age { get; set; }
}

Employee의 instance를 변경하는 method를 정의해야 한다면

public static void UpdateAge(Employee? emp, int age)
{
    if (emp is not null)
        emp.Age = age;
}

Null 조건 할당 연산자를 사용해 위와 동일한 구현을 아래와 같이 간소하게 표현할 수 있습니다.

public static void UpdateAge(Employee? emp, int age)
{
    emp?.Age = age;
}

즉, emp가 null이 아니라면 emp의 Age속성은 age값으로 변경되지만 그렇지 않다면 아무런 후속동작도 수행되지 않습니다.

Null 조건부 할당 연산자에 관해서는 아래 link를 참고해 더 자세히 알아볼 수 있습니다.

https://github.com/dotnet/csharplang/discussions/8676

Null-conditional assignment · dotnet csharplang · Discussion #8676

Summary Permits assignment to occur conditionally within a a?.b or a?[b] expression. using System; class C { public object obj; } void M(C? c) { c?.obj = new object(); } using System; class C { pub...

github.com

3) 논리 연산자(Logical operators)

논리연산자는 대게 boolean값을 평가하게 되므로 그 결과로 true나 false를 반환합니다.

논리연산자중 '이진 논리 연산자(binary logical operator)'는 2개 이상의 boolean값을 평가하는 것으로 연산방식에 따라 AND, OR, XOR(exclusive OR)로 나눌 수 있으며 아래와 같이 사용됩니다.

bool a = true;
bool b = false;

Console.WriteLine($"AND a : {a & a}");
Console.WriteLine($"AND b : {b & b}");
Console.WriteLine($"AND a/b : {a & b}");
Console.WriteLine();
Console.WriteLine($"OR a : {a | a}");
Console.WriteLine($"OR b : {b | b}");
Console.WriteLine($"OR a/b : {a | b}");
Console.WriteLine();
Console.WriteLine($"XOR a : {a ^ a}");
Console.WriteLine($"XOR b : {b ^ b}");
Console.WriteLine($"XOR a/b : {a ^ b}");

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제에서 사용된 '&'는 AND 논리연산자로, 피연산자 모두 true여야만 결과로 true를 표시합니다. '|'문자는 OR 연산자로 이 경우에는 피연산자중 단 하나만 true여도 그 결과로 true를 반환하며, '^'문자는 XOR 연산자로 피연산자중 하나면 true여도 그 결과로 true를 반환하지만 피연산자 모두 true여서는 안됩니다.

(1) 조건부 논리 연산자(Conditional logical operators)

조건부 논리 연산자는 위에서 소개한 논리연산자를 이중으로 표현(&&, ||)한 것을 말하는 것으로 조건에 따라 연산처리의 수행여부를 결정합니다. 예제를 위해 우선 아래와 같은 간단한 함수 하나를 추가합니다.

static bool DoSomething()
{
    Console.WriteLine("함수 실행됨.");
    return true;
}

위 예제는 top-level program 기능을 사용하는 경우라면 Program.cs의 어디에 만들어도 문제가 되지 않지만 가급적 가장 아래에 배치하는 것이 좋습니다.

위 함수는 호출되면 간단한 message를 표시한 뒤 그 결과로 true값을 반환합니다. 함수나 method의 작성에 관한 자세한 사항은 추후에 자세히 다룰 것이므로 지금은 예제의 함수가 어떤동작을 하고 어떤 것을 반환하는지만 알아두면 충분합니다.

함수를 만들고 나면 그 위에 아래의 구문을 추가합니다.

bool a = true;
bool b = false;

Console.WriteLine($"a & DoSomething() : {a & DoSomething()}");
Console.WriteLine($"b & DoSomething() : {b & DoSomething()}");

그리고 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

결과를 보면 각각의 연산작업에 2번씩 실행되었음을 알 수 있습니다. 여기서 어떤 분들은 위 결과에 대해 a는 납득이 되지만 b는 그렇지 않다라는 생각을 가질 수도 있습니다. 왜냐하면 '&'는 AND연산으로 피연산자 모두가 true여야만 그 결과가 true가 되는데 b는 처음부터 false로 시작하기 때문에 굳이 함수를 실행하지 않아도, 즉, 함수의 실행여부와는 관계없이 그 결과가 false가 되기 때문입니다. 다시 말해 b를 피연산자로 하는 경우 함수를 실행할 필요가 없다는 결론에 이르게 되는 것입니다. 하지만 단순한 논리연산자는 이러한 경우를 감안할 수 없으므로 무엇인가 다른방식을 적용해야 하고 그 결과로 조건부 논리 연산자가 등장하게 되었습니다.

이번에는 위 예제를 아래와 같이 바꿔보겠습니다.

Console.WriteLine($"a && DoSomething() : {a && DoSomething()}");
Console.WriteLine($"b && DoSomething() : {b && DoSomething()}");

예제를 변경하고 다시 실행하면 이번에는 다른 결과를 표시할 것입니다.

이번에는 a변수에 대해서만 함수가 두번 실행되었고 b에서는 한번만 실행되었음을 알 수 있습니다. b는 false이므로 그 뒤 어떤 값이 오더라도 결과는 false가 될것이고 따라서 함수를 실행하는게 무의합니다. '&&'연산자는 바로 이러한 조건의 논리를 그대로 적용하기 때문에 위와 같은 결과를 만들어낼 수 있습니다.

위에서 설명한 조건부 논리 연산자의 특징 때문에 이를 단락(Short-circuiting)으로 표현하기도 합니다. 조건부 논리 연산자는 적절히 사용하면 Application을 더욱 효휼적으로 작성할 수 있지만 자칫 예기치 않은 bug를 만들어낼 가능성도 있습니다. 특히 함수가 항상 실행되어야 한다거나 내지는 실행된다라고 예상하는 경우 Application의 흐름을 전혀 다른 방향으로 이끌 수 있으므로 함수와의 결합하여 사용할때는 특히 주의해야 합니다.

4) Bit 연산자 및 이진 shift 연산자

Bit연산자는 2개 이상의 bit로 표현된 값에서 동일한 column의 각 bit를 비교하는 연산자이며, 이진 shift 연산자는 bit값을 이동시키는 연산자로서 이러한 특징을 이용하면 일반적인 산술연산자보다 더 빠른 속도로 산술연산을 수행할 수 있습니다.

해당 연산자의 예제를 만들어보기 위해 우선 아래와 같이 2개의 int형 변수를 선언합니다.

int i = 10;
int j = 4;

Console.WriteLine($"i : {i, 3} | {i:B8}");
Console.WriteLine($"j : {j, 3} | {j:B8}");

예제에서 숫자 3은 3개 column에 대한 오른쪽 정렬을, B8은 8자리 binary표시를 의미하므로 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

위 상태에서 bit연산자를 사용한 아래 예제를 추가합니다.

Console.WriteLine();
Console.WriteLine($"i & j : {i & j, 3} | {i & j:B8}");
Console.WriteLine($"i | j : {i | j, 3} | {i | j:B8}");
Console.WriteLine($"i ^ j : {i ^ j, 3} | {i ^ j:B8}");

Bit연산자는 &, |, ^ 를 사용할 수 있으며 연산방식은 이전에 설명한 논리연산자와 동일합니다. 즉, 각 값의 bit를 비교해 &인 경우 AND이므로 동일한 값에 1을, |는 OR이므로 둘중 하나라도 1이면 1을, ^는 XOR이므로 둘중 하나만 1인 경우 1을 표시합니다.

&, | 연산자를 산술값에 적용하면 bit연산자가 되지만 boolean값에 적용하면 논리연산자가 됩니다.

이제 다음으로 Shift 연산자를 사용한 아래의 구문을 추가합니다.

Console.WriteLine();
Console.WriteLine($"i << 3 : {i << 3} | {i << 3:B8}");
Console.WriteLine($"i *  8 : {i * 8} | {i * 8:B8}");
Console.WriteLine($"j >> 1 : {j >> 1} | {j >> 1:B8}");
Console.WriteLine($"j - 2 : {j - 2} | {j - 2:B8}");

예제를 실행하면 다음과 같은 결과를 표시합니다.

예제에서 'i << 3'은 왼쪽 i값의 bit를 왼쪽으로 3column 이동하도록 합니다. 이동하면서 왼쪽으로 밀려난 값은 버려지며 오른쪽은 0으로 채워집니다. 그런데 예제의 결과에서 나타난것 처럼 이러한 동작은 값에 곱하기 8(* 8)을 한것과 동일한 결과를 만들어냅니다. 왼쪽부터 첫번째 1값은 64이고 두번째 1값은 16이기 때문에 결과는 80이 되기 때문입니다. 변수 j에 대한것도 마찬가지인데 'j << 1'은 오른쪽으로 1column이동하도록 하며 그 결과는 산술연산에서 -2와 동일한 결과를 나타냅니다. shift연산자는 산술연산과 동일한 결과를 만들어내면서도 더 빠른 동작을 수행할 수 있다는 특징이 있습니다.

5) 기타 연산자

nameof은 변수나 type, member에 대해 약식이름을 반환하는 연산자이며 sizeof는 type에서 필요로 하는 memory size를 byte단위로 반환하는 연산자입니다. 기술적으로 sizeof는 unsafe code block이 필요하지만 type을 지정할때 int나 double와 같은 C# 별칭을 사용하면 unsafe를 사용하지 않아도 됩니다.

int i = 10;
Console.WriteLine($"변수 {nameof(i)}는 약 {sizeof(int)} byte의 memory를 필요로 합니다.");

이 밖에도 type의 member를 가져오기 위해 사용하는 dot(.)도 'member 접근 연산자'라고 하는 연산자이며 method의 뒤에 붙이는 괄호(())역시 호출 연산자(Invocation operator)라고 하는 연산자에 해당합니다.

int i = 10;
string iname = i.ToString();

2. 선택문(분기문)

선택문은 서로 다른 code간의 분기를 위한 구문을 말합니다. C#에서 사용가능한 선택문으로는 if와 switch문이 있는데 이 둘은 '선택'이라는 측면에서 비슷하지만 swicth는 일부 일반적인 상황에서 if보다 더 code를 단순화시키면서도 효휼적인 선택처리가 가능합니다. 곧 보게 되겠지만 switch는 특히, 하나의 변수에 대해 각기 다른 처리를 필요로 하는 다양한 값을 가질 수 있는 경우에 유용하게 사용할 수 있습니다.

1) if를 사용한 분기

if문은 boolean 형식의 문을 평가한 뒤 그 결과를 토대로 분기를 결정하는 것으로서 만약 평가 결과가 true라면 내부의 block문을 실행하게 됩니다. else문은 평가 결과가 false인 경우 실행하는데 이는 선택적이라 필요한 경우에만 추가할 수 있습니다. 또한 if문은 충첩될 수 있습니다.

if문은 아래와 같은 형식으로 구현할 수 있습니다.

if (조건식1)
{
    //조건1이 true인 경우 실행
}
else if (조건식2)
{
    //상기 조건1이 false이고 조건2가 true인 경우 실행
}
else
{
    //상기 모든 조건이 false인 경우 실행
}

각 if문의 조건식은 독립적으로 구현할 수 있으며 switch와는 달리 단일값을 사용할 필요는 없습니다. 또한 else if와 else는 선택적으로 필요한 경우에만 사용합니다.

아래 예제는 if문을 사용해 비밀번호를 학인하고 그에 따른 처리를 수행하는 방법을 나타내고 있습니다.

string password = "abc123";
string userInput = Console.ReadLine();

if (userInput == password)
{
    Console.WriteLine("비밀번호가 일치합니다.");
}
else
{
    Console.WriteLine("비밀번호가 일치하지 않습니다.");
}

예제를 실행하면 다음과 같은 결과를 표시할 것입니다. 결과는 입력한 값에 따라 달라질 수 있습니다.

(1) 괄호사용에 관해

Block은 기본적으로 괄호를 통해 표현되며 C#명세에서는 block을 복합문(compound statement)으로 언급하고 있습니다. 본래 block안의 실행문은 단일문이 와야하지만 이를 중괄호를 사용해 여러 구문으로 묶어 놓을 수 있다는 것을 나타내는 것입니다.

if, else, while 및 for와 같은 C#의 모든 제어문에서는 괄호를 사용하지 않고 단일문을 사용하되 그 이상의 문이 필요하다면 괄호를 사용해 하나의 덩어리로 묶어놓아야 합니다. 이러한 것을 삽입문(embedded statement)이라고 하는데 block이나 복합문은 이 삽입문중 하나이며 괄호를 사용하지 않는 단일문 역시 또 다른 style의 삽입문에 해당합니다.

띠라서 위 예제를 단일구문으로 변경하는 경우 괄호를 제거하고 아래와 같이 구현할 수 있습니다.

string password = "abc123";
string userInput = Console.ReadLine();

if (userInput == password)
    Console.WriteLine("비밀번호가 일치합니다.");
else
    Console.WriteLine("비밀번호가 일치하지 않습니다.");

보기에는 언뜻 code가 깔끔해 보일 수 있지만 사실 위와 같은 coding style은 중대한 결함을 만들 수 있기에 피하는 것이 좋습니다. 단지 예제에서의 if문뿐만 아니라 단일문을 허용하는 모든 제어문에서 괄호를 사용하지 않는 단일문의 사용은 권장되지 않습니다.

괄호를 사용하지 않아도 된다고 해서 꼭 그렇게 해야하는 것은 아닙니다. 괄호를 사용하지 않음으로인해 code가 효휼적으로 변하는 것도 아닙니다. 오히려 code를 읽기 어렵게 하고 관리성도 떨어지며 잠재적으로 위험한 code를 만들어낼 수도 있습니다. 예제에서는 공간의 활용을 위해 괄호를 생략할 수 있지만 실제 그러한 code를 작성하지 않도록 해야 합니다.

(2) if문에서의 조기반환 또는 guard절(Early return or guard clause)

'조기반환 또는 guard절'은 값을 반환하는 method안에서 if문을 사용하는 경우 상황에 따라 else를 사용하기 보다 if문의 조건이 만족하면(또는 만족하지 않으면) 곧장 값을 반환함으로서 code의 중첩이 깊어지는 문제를 해결하고자 하는 방법입니다.

예를 들어 아래와 같은 Method가 있다면

public bool IsSchoolZoneSpeeding(int speed)
{
    if (speed > 30)
    {
        return true;
    }
    else
    {
        return false;
    }
}

위의 예제를 조기반환 또는 guard절로 변경하게 되면 아래와 같이 구현할 수 있습니다.

public bool IsSchoolZoneSpeeding(int speed)
{
    if (speed > 30)
    {
        return true;
    }
    
    return false;
}

위와 같은 방식은 가급적 중첩을 줄임으로서 code의 가독성을 향상시킬 수 있고 잘못된경우 혹은 경계조건에서 조기에 단락을 실행함으로서 code실행의 효휼성을 가져올 수 있습니다. 또한 code상에서 가장 우선적이거나 중요한점을 부각할 수 있다는 이점도 있습니다.

특히 이러한 방식은 ASP.NET Core와 같은 framework에서 조기에 입력값이나 상태의 유효성을 검증하고 사전에 값을 반환함으로서 code의 흐름을 간소화하고자 하는 방법으로 아래와 같이 광범위하게 사용되고 있습니다.

public IActionResult ProcessOrder(Order order)
{
    if (order == null)
    {
        return BadRequest();
    }
    
    if (!order.IsValid())
    {
        return UnprocessableEntity();
    }
    
    // Normal processing
    _orderService.Save(order);
    
    return Ok();
}

위의 code에서 볼 수 있는 것처럼 else를 사용하지 않으면서 각각 잘못된 경우에 도달했을때 이를 처리하여 즉각적으로 method를 빠져나오도록 code를 설계하고 있습니다.

(3) 조건의 분리

if문에서 조건문을 사용할때 조건문 자체가 너무 길어지는 경우 이를 전부 if문안에 넣기 보다 따로 분리하여 지정하는 편이 좋습니다. 예를 들어

string password = Console.ReadLine();

if (password.Length >= 8 &&
    char.IsLetterOrDigit(password[0]) == false &&
    password.Any(char.IsDigit))
{
    //
}

위와 같은 if문에서는 입력된 비밀번호가 8자 이상이면서 첫글자가 특수문자이고 숫자가 포함되어 있는지 여부를 확인하고 있습니다. 이렇게 복작한 조건의 경우는 아래와 같이 분리하면 code의 가독성을 훨씬 향상시킬 수 있습니다.

string password = Console.ReadLine();

bool isPasswordVaild = password.Length >= 8 && //8자이상
    char.IsLetterOrDigit(password[0]) == false && //첫글자의 특수문자여부
    password.Any(char.IsDigit); //숫자포함여부

if (isPasswordVaild) //비밀번호의 유효성 검증
{
    ///
}

(4) if문에서의 pattern matching

Pattern matching은 C#7에서 도입된 기능으로 if문에서는 is keyword를 사용해 변수의 선언과 결합함으로서 code를 더 안전하게 만들 수 있습니다.

object s = "2";
int i = 1;

if (s is int j)
{
    Console.WriteLine($"{i + j}");
}
else
{
    Console.WriteLine("변수 s는 int type이 아닙니다.");
}

위 예제에서는 if문의 조건식에서 's is int j'를 통해 is keyword를 사용하고 있습니다. 이렇게 하면 변수 s의 type을 확인하고 만약 type이 int라면 s의 값을 변수 j에 할당하게 됩니다. 그리고 이렇게 할당된 j는 if문 내부에서 자유롭게 사용할 수 있습니다. 여기서 중요한점은 이러한 방식으로 지역변수 j를 사용하면 최소한 j가 int형이라는 점을 보장할 수 있기 때문에 int에서 수행할 수 있는 작업을 더 안전하게 수행할 수 있다는 것입니다.

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

object s에 들어가는 값이 처음부터 "2"와 같은 방법을 통해 문자열로 저장하고 있으므로 s는 문자열 type이 되고 따라서 위와 같은 결과를 표시하게 됩니다.

위 예제를 "2" 대신 아래와 같이 변경하여 s변수에 2의 값이 int으로 저장되도록 하고

object s = 2;

예제를 다시 실행하면 이번에는 다른 결과를 표시하게 될 것입니다.

is 연산자에 대한 더 자세한 내용은 아래 link를 참고하시기 바랍니다.
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/is

The `is` operator - Match an expression against a type or constant pattern - C# reference

Learn about the C# `is` operator that matches an expression against a pattern. The `is` operator returns true when the expression matches the pattern.

learn.microsoft.com

2) Switch

Switch문은 하나의 단일값을 여러개의 가능한 다른 값으로 비교하고 해당 값의 case문으로 처리를 분기하는 분기문입니다. 이때 각 case문은 아래의 방법중 하나로 끝을 맺어야 합니다.

break keyword 사용
goto case keyword 사용
어떠한 구문도 없음
다른 label을 참조하는 goto keyword 사용
현재 처리를 벗어나는 return keyword 사용

아래는 일반적인 switch의 사용법을 나타내는 예제입니다. 각 case문에서 위와 같은 규칙이 적용되어 있음에 주목하시기 바랍니다.

int i = 2;

switch(i)
{
    case 1:
        Console.WriteLine("1");
        break;
    case 2:
        Console.WriteLine("2");
        goto case 1;
    case 3:
    case 4:
        goto Jump;
    default:
        Console.WriteLine("etc...");
        break;
}

Jump:
    Console.WriteLine("jumped!");

예제에서 goto keyword는 다른 case나 지정한 label로 code의 흐름을 이동시키기서 사용됩니다. 그런데 대부분의 개발자들사이에서 goto문은 소위 'spaghetti code'를 만들 수 있다는 인식때문에 피해야할 대상으로 여겨지고 있습니다. 하지만 일부 scenario에서는 최선의 해결책이 될 수도 있습니다. 실제 Microsoft에서도 .NET Class library에 goto문을 사용하곤 합니다.

https://github.com/search?q=%22goto%20%22+repo%3Adotnet%2Fruntime+language%3AC%23&type=code&ref=advsearch

GitHub · Change is constant. GitHub keeps you ahead.

Join the world's most widely adopted, AI-powered developer platform where millions of developers, businesses, and the largest open source community build software that advances humanity.

github.com

goto는 편리한 만큼 code를 복잡하게 만들 수 있다는 양면성을 가지고 있으므로 남발하지 말고 꼭 필요한 곳에만 쓰도록 해야 합니다.

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

상기 결과는 i변수에 설정되는 값에 따라 달라질 수 있습니다.

'Jump:' Label문은 goto문의 의해 이동되어 실행될 뿐만 아니라 위에서 아래로 흐르는 code의 흐름을 통해 실행될 수도 있습니다.

(1) Switch문에서의 pattern matching

if문과 마찬가지로 switch문에서도 pattern matching을 지원합니다. 따라서 case문에서는 기존 literal값대신 pattern을 대신 사용할 수 있습니다.

C#7 부터 class의 하위 type에 기반하여 code를 더 간결하게 분기할 수 있게 되었으며 지역변수의 선언과 할당을 통해 이를 더 안전하게 사용할 수 있습니다. 또한 case에서는 when keyword를 도입함으로서 더 세부적인 pattern matching을 수행할 수 있습니다.

우선 switch에서의 pattern matching을 사용해 보기 위해 아래와 같은 class를 정의합니다.

class에 관한 자세한 사항은 추후에 자세히 알아볼 것입니다.

class Car
{
    public string ModelName;
    public int MaxSpeed;
    public DateTime Release;
}

class Sedan : Car
{
    public bool IsGasoline;
}

class Truck : Car
{
    public bool IsDiesel;
}

예제에서 Sedan과 Truck은 Car의 하위 class(sub type)이며 Car는 최상위 부모 class에 해당합니다.

이제 아래와 같이 Cars 배열을 선언하고 각 type에 따라 분기하여 type과 속성명을 표시하도록 합니다.

var cars = new Car?[] {
    new Sedan {
        ModelName = "Sonta", MaxSpeed = 200, Release = new( year: 2019, month: 12, day: 04 )
    },
    null,
    new Sedan {
        ModelName = "Avan", MaxSpeed = 180, Release = new ( year: 2022, month: 05, day: 15 ), IsGasoline = false
    },
    new Truck {
        ModelName = "Manbo", MaxSpeed = 150, Release = new ( year: 2012, month: 03, day: 29 )
    }
};

foreach (Car? car in cars)
{
    switch (car) {
        case Sedan speedCar when speedCar.MaxSpeed == 200:
            Console.WriteLine($"{speedCar.ModelName}이 가장 빠른 차량임");
            break;
        case Sedan gCar when gCar.IsGasoline = false:
            Console.WriteLine($"{gCar.ModelName}차량은 휘발유를 사용하지 않음");
            break;
        default:
            Console.WriteLine("그 외");
            break;
        case null:
            Console.WriteLine("개체가 null상태임");
            break;
        case Truck truck:
            Console.WriteLine($"{truck.ModelName}은 {truck.Release.Year}년에 출시된 truck임.");
            break;
    }
};

예제를 보면 default를 switch가운데 정의하였는데 이는 이런것도 가능하다는 것을 보여주기 위해 고의적으로 배치한 것이므로 실제 switch문을 작성할때는 default를 항상 마지막에 정의하여야 합니다.

'case Sedan speedCar when speedCar.MaxSpeed == 200;' 해당 구문은 속성 pattern matching을 통해 아래와 같이 더 간소하게 구현할 수 있습니다.
'case Sedan { MaxSpeed : 200 } speedCar:'

예제에서는 Car? type의 cars array를 정의하였으므로 Car type을 상속받은 모든 하위 type이 올 수 있습니다. 또한 '?'문자를 통해 null가능한 type이 되었으므로 null역시 수용할 수 있습니다. 따라서 위에서 정의한 array의 순회하면서 각각의 조건에 맞는 type에 따라 아래와 같은 결과를 표시할 것입니다.

(2) switch 표현식

switch 표현식은 C#8부터 사용가능한 것으로 일반적인 switch문을 더욱 간소화할 수 있습니다.

위 예제와 같은 switch문이 그리 복잡한 것은 아니지만 지금 소개할 switch 표현식은 각 case문에서 값을 반환하는 기존 방식과 달리 lambda(=>)를 사용하여 반환값을 나타냄으로서 구문자체를 간소화하기 때문입니다.

아래 예제는 이전 switch 예제에서 switch 표현식을 적용한 결과를 나타내고 있습니다.

string msg;
foreach (Car? car in cars)
{
    msg = car switch
    {
        Sedan speedCar when speedCar.MaxSpeed == 200 => $"{speedCar.ModelName}이 가장 빠른 차량임",
        Sedan gCar when gCar.IsGasoline == false => $"{gCar.ModelName}차량은 휘발유를 사용하지 않음",
        Truck truck => $"{truck.ModelName}은 {truck.Release.Year}년에 출시된 truck임.",
        null => "개체가 null상태임",
        _ => "그 외"
    };

    Console.WriteLine(msg);
};

상기 예제와 이전의 swicth와의 가장 큰 차이는 case와 break가 존재하지 않는다는 것입니다. 또한 예제에서 underscore(_)문자는 이전 case에서의 default에 해당하며 이를 'discard'라고 합니다. 관련된 더 자세한 사항은 아래 link를 참고하시기 바랍니다.

Discards - unassigned discardable variables - C# | Microsoft Learn

Discards - unassigned discardable variables - C#

Describes C#'s support for discards, which are unassigned, discardable variables, and the ways in which discards can be used.

learn.microsoft.com

예제를 실행하면 이전과 동일한 결과를 표시할 것입니다.

3. 반복문

반복문은 구문의 block을 반복하는 구문으로서 while이나 for문에서 조건이 true면 반복을 실행하며, foreach문에서는 collecction안의 각 item을 순회하는 목적으로 사용됩니다. for, while 또는 foreach를 선택하는 기준은 현재 문제를 해결하기에 가장 적합한 것과 개인적인 선호도에 따라 달라질 수 있으며 딱히 정재진 규칙은 없습니다.

1) while

while문은 boolean식을 평가한 뒤 그 결과가 true면 계속해서 해당 block을 반복하는 구문입니다.

아래 예제는 while을 사용하는 간단한 예제를 나타낸 것입니다. 주어진 조건(i < 10)이 false를 반환할때까지 내부 {}사이의 code를 계속 반복하게 되며 결과적으로 0부터 9까지 숫자를 표시하고 동작을 종료할 것입니다.

int i = 0;

while (i < 10)
{
    Console.WriteLine(i);
    ++i;
}

예제를 실행하면 다음과 같은 결과를 표시합니다.

2) do

위에서 언급한 while문은 시작할때부터 boolean조건을 평가하지만 do는 일단 한번 실행한 뒤에 그 다음 boolean조건을 평가한다는 차이가 있습니다. 이것 외에는 동작방식이 거의 while과 일치합니다.

아래 예제는 do를 사용하는 간단한 예제를 나타낸 것입니다.

int right = 5;
int answer = 0;
do
{
    Console.WriteLine("2 + 3 = ?");
    answer = int.Parse(Console.ReadLine());
}
while(right != answer);

do문은 일단 내부의 구문을 최소 한번은 실행하게 됩니다. 따라서 boolean식 조건도 위가 아닌 하단에 위치하게 됩니다.

예제를 실행하면 다음과 같은 결과를 표시할 것입니다. Application은 사용자에게 질문의 답을 요청하게 되고 그 정답이 입력될때까지 같은 질문을 반복하게 됩니다.

3) for

for문은 아래와 같은 조합으로 만들어집니다.

초기화 표현식	loop를 시작할때 한번은 실행되는 부분으로 반복문의 초기값을 설정합니다. 별다른 초기화가 필요하지 않으면 생략할 수 있습니다.
조건 표현식	loop가 실행될때 마다 실행되는 부분으로 반복문의 실행여부를 확인하는 부분입니다. 만약 해당 표현식에서 true를 반환한다면 loop는 다시 재실행됩니다. 경우에 따라 생략이 가능한데 자칫 무한 loop가 될 수 있으므로 내부실행부분에서 loop를 빠져나가기 위한 처리를 추가해야 합니다.
반복 표현식	loop의 실행이 종료될때마다 실행되는 부분으로 대부분 값의 증가나 감소처리를 진행합니다.

아래 예제는 for문을 사용하여 1부터 10까지 숫자를 나타내도록 하고 있습니다.

for (int i = 1; i <= 10; i++)
{
    Console.WriteLine(i);
}

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제에서 'int i = 1'이 초기화, 'i <= 10'이 조건, 'i++'이 반복 표현식에 해당합니다. 만약 이 모두를 생략하고 for문을 작성해야 한다면 다음과 같이 작성할 수 있습니다.

for (;;)
{
    ...
}

4) foreach

상기 for문은 값의 변화에 따른 반복을 수행하지만 foreach문은 array나 List와 같이 배열을 열거하는데 사용됩니다. 이때 열거대상인 배열은 읽기전용상태가 되므로 만약 기존 item을 삭제하거나 추가하려고 시도하면 예외를 발생시키게 됩니다.

아래 예제는 foreach문을 통해 문자열값의 List를 대상으로 열거하며, 각각의 item을 표시하고 있습니다.

List<string> fruits = ["Apple", "Banana", "Strawberry"];

foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

위 예제를 실행하면 다음과 같이 표시할 것입니다.

List및 관련 내용에 관한 더 자세한 사항은 추후에 알아볼 것입니다.

(1) foreach문의 동작방식

만약 array나 collection과 같이 다수의 item을 표현하는 type을 정의하고자 한다면 해당 type이 foreach문을 통해 열거가능함을 알려줄 필요가 있고 따라서 아래와 같은 규칙이 준수되어야 합니다. 아무리 foreach라도 주어진 type이 열거가능함을 foreach스스로가 알 수 있는 방법이 없기 때문입니다.

ⓐ type은 object를 반환하는 GetEnumerator라는 이름의 method를 가지고 있어야 합니다.
ⓑ ⓐ에서 반환된 개체는 반드시 Current라는 속성과 MoveNext라는 method를 가지고 있어야 합니다.
ⓒ MoveNext method는 반드시 Current속성값을 변경해야 하며 열거 가능한 item이 존재하는 경우 true를 그렇지 않으면 false를 반환해야 합니다.

.NET에서는 위와 같은 규칙을 어떤 type이든 일관성있게 적용하기 위해 IEnumerable과 IEnumerable<T> interface를 제공하고 있으며 해당 interface를 통해 상기 규칙을 정의하고 있습니다.(다만 해당 interface의 규칙을 강제하지는 않습니다.)

사실 compiler는 이전 예제와 같은 code를 아래와 같은 형식으로 처리하고 있는데

IEnumerator e = fruits.GetEnumerator();

while (e.MoveNext())
{
    string fruit = (string)e.Current;
    Console.WriteLine(fruit);
}

보시는 바와 같이 iterator와 해당 읽기전용의 Current속성을 사용하기 때문에 foreach문안에 선언된 변수는 현재 item의 값을 변경하는데 사용할 수 없습니다.

또한 예제에서는 fruits의 변수에 List<string> type을 사용하였는데 만약 이 type이 아래와 같이 단순 배열(array)이라면

string[] fruits = ["Apple", "Banana", "Strawberry"];

Compiler는 배열이 IEnumerable<T> interface를 구현한다는 것을 무시하고 이를 사용하는 대신 조금 더 효휼적으로 array의 Length속성을 사용하는 for문을 작성하여 아래와 같이 구현합니다.

for (int len = 0; len < fruits.Length; len++)
{
    Console.WriteLine(fruits[len]);
}

4. 배열(Array)

동일한 Type이면서 다수의 값을 한꺼번에 저장해야 한다면 array를 사용할 수 있습니다. 이전 예제에서도 문자열 type의 과일 이름을 다수로 저장하는데 array를 사용하였습니다.

1) 1차원 Array

다수의 값을 한꺼번에 저장하는 array는 보통 내부 요소를 저장할때 최초 0부터 시작하는 zero 하한선(lower bound of zero)을 사용하므로 각 요소는 0부터 3까지 index값을 가지고 저장됩니다. 따라서 마지막 item의 index는 array의 크기의 -1값을 됩니다.

다음 이미지는 1차원 array가 값을 저장할때 상태를 나타낸 것입니다.

Array가 item을 저장할때 항상 0부터 시작된다고 단정지어서는 안됩니다. .NET에서 array의 가장 일반적인 type은 []문법을 사용하는 szArray(Single-dimensional Zero-indexed array)이지만 다차원 array인 mdArray도 제공하고 있으며 이는 'zero 하한선'을 사용하지 않습니다. 물론 흔하게 사용되는건 아니지만 이런것도 있다는 것을 알려드리고자 합니다.

아래 예제는 1차원 array에 4개의 문자열값을 저장하고 이를 for문으로 순회하면서 해당 요소를 화면으로 표시하도록 하고 있습니다.

string[] fruits;

fruits = new string[4];

fruits[0] = "Apple";
fruits[1] = "Banana";
fruits[2] = "Watermelon";
fruits[3] = "Orange";

for (int i = 0; i < fruits.Length; i++)
{
    Console.WriteLine($"{fruits[len]} of {i}");
}

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제를 보면 array를 선언한 뒤에 아래와 같이 array의 instance를 생성하고 있습니다.

fruits = new string[4];

Array는 memory에 할당되는 시점에 항상 고정된 값의 크기를 지정해야 합니다. 따라서 array를 선언하고 할당하기 전에는 해당 array에 얼마나 많은 item을 담을 것인지 예상하고 그에 맞는 크기를 지정하는 것이 필요합니다. 또는 array를 선언하고 지정된 item을 아래와 같이 저장하면 자동으로 해당 item의 수만큼 array의 size를 확보하기 때문에 좀더 간결하게 array를 초기화 할 수 있습니다.

string[] fruits = { "Apple", "Banana", "Watermelon", "Orange"};

2) 다차원 Array

string이나 다른 data type을 하나의 줄로만 계속 연결해서 저장하려면 1차원 array만으로 충분하지만 array를 통해 table형태로 값을 저장하려면 다차원 array가 필요합니다.

예를 들어 array를 2차원으로 구성한다면 아래와 같은 그림으로 표현할 수 있습니다.

위 그림은 다차원중에서도 array를 2개 사용하는 2차원을 표현한 것인데 이를 code를 바꾸면 아래와 같이 구현할 수 있습니다.

string[,] twoArray =
{
    { "a", "b", "c", "d" },
    { "aa", "bb", "cc", "dd" },
    { "aaa", "bbbb", "ccc", "ddd" }
};

'string[,]'구문에서 comma가 사용되었는데 이를 통해 string type의 array를 2차원으로 선언한 것이 됩니다. 혹은 다음과 같은 방법이 사용되기도 하는데

string[,] twoArray = new string[3, 4];
twoArray[0, 0] = "a";
twoArray[0, 1] = "b";
twoArray[0, 2] = "c";
twoArray[0, 3] = "d";
twoArray[1, 0] = "aa";
twoArray[1, 1] = "bb";
twoArray[1, 2] = "cc";
twoArray[1, 3] = "dd";
twoArray[2, 0] = "aaa";
twoArray[2, 1] = "bbb";
twoArray[2, 2] = "ccc";
twoArray[2, 3] = "ddd";

위 방법은 array의 선언과 할당을 분리하는 것으로, 사실 array의 차원을 이해하는데는 오히려 위와 같은 code가 더 도움이 될 수 있습니다. 또한 database나 file과 같이 외부에서 runtime에 값을 설정해야 하는 경우라면 이러한 방법을 사용해야 합니다.

array를 선언할때 []안에서는 comma(,)를 기준으로 첫번째 숫자가 첫번째 차원의 길이를, 두번째 숫자가 두번째 차원의 길이를 나타냅니다. 요소를 가져올때 붙이는 최대상한선의 index를 의미하는 것이 아니므로 주의해야 합니다.

array에서 각 차원의 하한선과 상한선은 다음과 같이 해당 array의 GetLowerBound와 GetUpperBound라는 2개의 method를 통해 확인할 수 있습니다.

Console.WriteLine($"1 dimension lower bound : {twoArray.GetLowerBound(0)}");
Console.WriteLine($"1 dimension uppper bound : {twoArray.GetUpperBound(0)}");
Console.WriteLine($"2 dimension lower bound : {twoArray.GetLowerBound(1)}");
Console.WriteLine($"2 dimension uppper bound : {twoArray.GetUpperBound(1)}");

위 예제를 실행하면 다음과 같이 표시할 것입니다.

이제 위 array에 대한 값을 어떻게 확인할 수 있을지 생각해 봅시다. 1차원 array에서는 단 하나의 for문만 있으면 되지만 위 예제처럼 2차원이라면 for문을 하나 더 추가해야 하며, 이렇게 만들어진 2개의 중첩된 for문을 통해 array를 순회하여 값을 표시할 수 있습니다.

for (int row = 0; row <= twoArray.GetUpperBound(0); row++)
{
    for (int col = 0; col <= twoArray.GetUpperBound(1); col++)
    {
        Console.WriteLine($"{row} Row, {col} Column : {twoArray[row, col]}")
    }
}

위 예제에서 바깥쪽 for문은 첫번째 차원을, 그 다음 for문은 두번째 차원을 순회합니다.

array를 선언할때의 예제를 보면 array를 초기화 할때 각 row와 column에 들어갈 모든 값을 지정하고 있습니다. 이렇게 하지 않으면 오류가 발생하는데 만약 중간에 값을 비워둬야 한다면 string type의 경우 string.Empty로 이를 대신할 수 있습니다.

string[,] twoArray =
{
    { string.Empty, "b", "c", "d" },
    { "aa", "bb", string.Empty, "dd" },
    { "aaa", "bbbb", "ccc", string.Empty }
};

string.Empty는 말그대로 공백을 의미합니다. 또는 null처럼 공백이 아닌 아예 없는 것으로 만들어야 한다면 'string?[,]'과 같이 null을 허용하게끔 array를 선언하고 null keyword로 값을 비워두면 됩니다.

string?[,] twoArray =
{
    { null, "b", "c", "d" },
    { "aa", "bb", null, "dd" },
    { "aaa", "bbbb", "ccc", null }
};

3) 가변배열(jagged arrays)

가변배열은 다차원배열과 비슷하지만 각각 차원이 다른 요소를 저장할 수 있는 배열을 말합니다.

가변배열을 시각화하면 다음과 같이 나타낼 수 있으며

이를 code화 하면 아래와 같이 구현할 수 있습니다.

string[][] jaggedArray =
[
    [ "a", "b", "c" ],
    [ "aa", "bb", "cc", "dd" ],
    [ "aaa", "bbb" ],
];

만약 C#11 이전의 version을 사용한다면 위의 대괄호를 사용할 수 없고 아래와 같이 중괄호와 함께 new keyword를 사용하여 instance화 해야 합니다.

string[][] jaggedArray =
{
    new[] { "a", "b", "c" },
    new[] { "aa", "bb", "cc", "dd" },
    new[] { "aaa", "bbb" }
};

가변배열역시 GetLowerBound()와 GetUpperBound() method를 통해 하산선과 상한선값을 가져올 수 있습니다.

for (int arr = 0; arr <= jaggedArray.GetUpperBound(0); arr++)
{
    Console.WriteLine($"Upper bound of array {arr} : {jaggedArray[arr].GetUpperBound(0)}");
}

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

값을 순회하는 방식역시 for문과 같은 반복문을 사용하면 됩니다. 다만 가변배열은 각각의 row마다 새로운 array가 들어가 잇는 셈이므로 각 array에 대한 상한선을 구해 요소를 순회하여야 합니다.

for (int row = 0; row <= jaggedArray.GetUpperBound(0); row++)
{
    for (int col = 0; col <= jaggedArray[row].GetUpperBound(0); col++)
    {
        Console.WriteLine($"{row} Row, {col} Column : {jaggedArray[row][col]}");
    }
}

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

4) Array의 List Pattern Matching

위 예제에서는 어떠한 개체에 대해서 pattern matching을 사용해 어떤식으로 개체의 속성과 type을 비교할 수 있는지 살펴봤었습니다. 이러한 pattern matching은 array나 기타 collection에서도 적용할 수 있습니다.

C# 11에서 도입된 pattern matching은 public으로 정의된 Length나 Count 속성과 함께 int 혹은 System.Index 매개변수를 사용하는 indexer를 가진 type이라면 어떤 것에도 pattern matching을 적용할 수 있습니다.

indexer에 관한 자세한 사항은 추후에 알아볼 것입니다.

어떤 switch문안에서 다수의 list pattern을 정의할때는 가장 상세한 조건이 가장 먼저올 수 있도록 해야 합니다. 자세하지 않은 일반적인 pattern이 우선으로 오면 해당 pattern이 사전에 먼저 조건에 부합될 수 있고 결국 다음순서에 존재하는 상세 pattern까지 도달할 수 없게 될 것이기 때문입니다.

아래 표는 int값을 갖는 list로 가정할 경우 사용할 수 있는 list pattern의 예제를 나열하고 있습니다.

[]	빈 array 또는 collection과 일치합니다.
[..]	Array나 collection의 항목갯수가 0개이상일때와 일치합니다. 만약 '[]'와 '[..]'모두에서 조건이 거쳐가도록 하려면 이론상 '[..]'이 '[]'이후에 와야 합니다.
[int item1] or [var item1]	지정된 단일 항목을 가진 list와 일치합니다. 또한 반환표현식을 통해 일치하는 항목의 값을 반환하므로 item1을 참조해 값을 사용할 수 있습니다.
[1, 2]	정확히 지정한 2개의 항목을 지정한 순서대로 가진 list와 일치합니다.
[_, _]	2개의 item을 가진 모든 list와 일치합니다. underscore(_)는 단일값을 의미합니다.
[var item1, var item2]	2개의 item을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 값을 item1과 item2를 참조하여 사용할 수 있습니다.
[_, _, _]	3개의 item을 가진 모든 list와 일치합니다.
[var item1, ..]	하나 이상의 item을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 첫번째 item값을 item1을 참조하여 사용할 수 있습니다. '..'은 범위값을 의미합니다.
[var firstItem, .., var lastItem]	2개의 이상을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 첫번째 item과 마지막 item값을 firstItem과 lastItem을 참조해 사용할 수 있습니다.
[.., var lastItem]	하나 이상의 item을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 마지막 item값을 lastItem을 참조하여 사용할 수 있습니다.

예제를 위해 우선 아래와 같은 int형 type의 array를 선언하고

int[] _1Numbers = {};
int[] _2Numbers = { 1, 2, 5, 6 };
int[] _3Numbers = { 1, 2, 3, 4 };
int[] _4Numbers = { 1, 2, 8 };
int[] _5Numbers = { 1, 2 };
int[] _6Numbers = { 9, 10, 11, 12, 13 };
int[] _7Numbers = { 99 };

patterm matching을 사용할 switch 표현식을 작성합니다.

static string filtering(int[] numbers) => numbers switch
{
    [] => "_1NNumbers",
    [1, 2, _, 6] => "_2Numbers",
    [1, .., 4] => "_3Numbers",
    [1, 2, 8] => "_4Numbers",
    [int item1, int item2] => $"_5Numbers with {item1}, {item2}",
    [9, .. int[] nums] => $"_6Numbers with {nums.Length}",
    [..] => "etc.. _7Numbers"
};

이제 다음과 같이 각 array에 대해 filtering을 호출합니다.

Console.WriteLine(filtering(_1Numbers));
Console.WriteLine(filtering(_2Numbers));
Console.WriteLine(filtering(_3Numbers));
Console.WriteLine(filtering(_4Numbers));
Console.WriteLine(filtering(_5Numbers));
Console.WriteLine(filtering(_6Numbers));
Console.WriteLine(filtering(_7Numbers));

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

C#6 부터는 code안에서 함수를 정의할 수 있는 식본문member(Expression-bodied function members)를 지원하고 있으며 예제에서는 이를 사용해 filtering method를 구현하고 있습니다. 또한 '=>'문자를 사용하는 lambda를 통해 함수로 부터의 값반환을 표현하고 있습니다.

여기서는 Pattern matching에 대한 모든 것을 설명하지 않았습니다. 더 자세한 사항은 아래 link를 참고해 주시기 바랍니다.
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns#list-patterns

Patterns - Pattern matching using the is and switch expressions. - C# reference

Learn about the patterns supported by the `is` and `switch` expressions. Combine multiple patterns using the `and`, `or`, and `not` operators.

learn.microsoft.com

4) Array의 List Pattern Matching

위 예제에서는 pattern matching을 사용해 어떤식으로 개체의 속성과 type을 비교할 수 있는지 살펴봤었습니다. 이러한 pattern matching은 array나 기타 collection에서도 적용할 수 있습니다.

indexer에 관한 자세한 사항은 추후에 알아볼 것입니다.

어떤 switch문안에서 다수의 list pattern을 정의할때는 가장 상세한 조건이 가장 먼저올 수 있도록 해야 합니다. 상세적이지 않은 일반적인 pattern이 우선으로 오면 해당 pattern이 사전에 먼저 조건에 부합될 수 있고 결국 다음순서에 존재하는 상세 pattern까지는 도달할 수 없을지 모르기 때문입니다.

아래 표는 int값을 갖는 list로 가정할 경우 사용할 수 있는 list pattern의 예제를 나열하고 있습니다.

[]	빈 array 또는 collection과 일치합니다.
[..]	Array나 collection의 항목갯수가 0개이상일때와 일치합니다. 만약 '[]'와 '[..]'모두에서 조건이 거쳐가도록 하려면 이론상 '[..]'이 '[]'이후에 와야 합니다.
[int item1] or [var item1]	지정된 단일 항목을 가진 list와 일치합니다. 또한 반환표현식을 통해 일치하는 항목의 값을 반환하므로 item1을 참조해 값을 사용할 수 있습니다.
[1, 2]	정확히 지정한 2개의 항목을 지정한 순서대로 가진 list와 일치합니다.
[_, _]	2개의 item을 가진 모든 list와 일치합니다. underscore(_)는 단일값을 의미합니다.
[var item1, var item2]	2개의 item을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 값을 item1과 item2를 참조하여 사용할 수 있습니다.
[_, _, _]	3개의 item을 가진 모든 list와 일치합니다.
[var item1, ..]	하나 이상의 item을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 첫번째 item값을 item1을 참조하여 사용할 수 있습니다. '..'은 범위값을 의미합니다.
[var firstItem, .., var lastItem]	2개의 이상을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 첫번째 item과 마지막 item값을 firstItem과 lastItem을 참조해 사용할 수 있습니다.
[.., var lastItem]	하나 이상의 item을 가진 모든 list와 일치하며 반환표현식에 의해 반환되는 마지막 item값을 lastItem을 참조하여 사용할 수 있습니다.

예제를 위해 우선 아래와 같은 int형 type의 array를 선언하고

int[] _1Numbers = {};
int[] _2Numbers = { 1, 2, 5, 6 };
int[] _3Numbers = { 1, 2, 3, 4 };
int[] _4Numbers = { 1, 2, 8 };
int[] _5Numbers = { 1, 2 };
int[] _6Numbers = { 9, 10, 11, 12, 13 };
int[] _7Numbers = { 99 };

patterm matching을 사용할 switch 표현식을 작성합니다.

static string filtering(int[] numbers) => numbers switch
{
    [] => "_1NNumbers",
    [1, 2, _, 6] => "_2Numbers",
    [1, .., 4] => "_3Numbers",
    [1, 2, 8] => "_4Numbers",
    [int item1, int item2] => $"_5Numbers with {item1}, {item2}",
    [9, .. int[] nums] => $"_6Numbers with {nums.Length}",
    [..] => "etc.. _7Numbers",
};

이제 다음과 같이 각 array에 대해 filtering을 호출합니다.

Console.WriteLine(filtering(_1Numbers));
Console.WriteLine(filtering(_2Numbers));
Console.WriteLine(filtering(_3Numbers));
Console.WriteLine(filtering(_4Numbers));
Console.WriteLine(filtering(_5Numbers));
Console.WriteLine(filtering(_6Numbers));
Console.WriteLine(filtering(_7Numbers));

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

C#6 부터는 code안에서 함수를 정의할 수 있는 식본문member(Expression-bodied function members)를 지원하고 있으며 예제에서는 이를 사용해 filtering method를 구현하고 있습니다. 또한 '=>'문자를 사용하는 lambda를 통해 함수로 부터의 값반환을 표현하고 있습니다.

Pattern matching에 대한 보다 더 자세한 사항은 아래 link를 참고해 주시기 바랍니다.
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns#list-patterns

5) Trailing comma

위 예제를 다시 보면 마지막 '[..] => "etc.. _7Numbers"'끝에 comma가 붙어 있는데 이를 trailing comma라고 하며 comma뒤에 다른 요소가 더 나오지 않아도 compiler는 별다른 오류를 표시하지 않습니다.

C#과 같은 대부분의 언어에서는 이러한 방식의 comma를 허용하는데 위 예제처럼 다수의 item을 comma로 분리하는 경우(array나 collection초기화, enum 또는 switch표현식등)에 사용하며 향후에 comma를 추가하거나 제거하지 않아도 item순서를 쉽게 재정렬하거나 추가/삭제할 수 있습니다.

2008년 swicth표현식에서 trailing comma를 허용하는것에 대한 논의가 있었는데 관련 내용에 대해서는 아래 link를 참고 하시기 바랍니다.
https://github.com/dotnet/csharplang/issues/2098

Switch expressions currently disallow trailing comma · Issue #2098 · dotnet/csharplang

Update: LDM (1/9) decided to allow such trailing comma. @jcouv commented on Thu Dec 20 2018 Trailing commas are currently disallowed, which is inconvenient when copy/pasting a line. public class C ...

github.com

뿐만 아니라 JSON serializer도 이러한 방식을 사용할 수 있는 option을 가지고 있습니다.
https://learn.microsoft.com/en-us/dotnet/api/system.text.json.jsonserializeroptions.allowtrailingcommas?view=net-10.0

JsonSerializerOptions.AllowTrailingCommas Property (System.Text.Json)

Get or sets a value that indicates whether an extra comma at the end of a list of JSON values in an object or array is allowed (and ignored) within the JSON payload being deserialized.

learn.microsoft.com

6) inline array

C#12에 도입된 inline array는 .NET Runtime team에서 성능향상을 위해 사용한 기능으로 아래와 같이 struct에 inline array특성을 지정하여 사용합니다.

[System.Runtime.CompilerServices.InlineArray(5)]
public struct InArr
{
    private int _item;
}

위 예제를 실행하면 InlineArray를 통해 전달한 인수만큼 연속적인 메모리공간을 할당하여 배열을 생성하게 되며 일반적인 배열과 동일하게 다음과 같이 값을 설정할 수 있습니다.

InArr ia = new InArr();
for(int i = 0; i < 5; i++)
{
    ia[i] = i;
}

배열에 들어간 값을 가져오는 방식도 크게 다르지 않지만 대신 InlineArray는 Length속성이 없기 때문에 자체적으로는 배열의 길이를 확인할 방법이 없습니다. 따라서 동적으로 배열의 길이를 확인해야 한다면 여러가지 방법이 있겠지만 아래와 같이 Span을 경유하는 방식이 가장 편리할 것으로 보입니다.

Span<int> si = ia;
for(int i = 0; i < si.Length; i++)
{
    Console.WriteLine(si[i]);
}

inline array에 관한 좀더 자세한 사항은 아래 link를 참고 하시기 바랍니다.
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-12.0/inline-arrays

Inline arrays, or fixed sized buffers - C# feature specifications

Inline arrays provide a general-purpose and safe mechanism for declaring inline arrays within C# classes, structs, and interfaces.

learn.microsoft.com

7) Array와 collection

Array는 다수의 item을 임시적으로 저장하는데 유용하게 사용할 수 있지만 만약 item을 동적으로 추가하거나 삭제하는 경우가 있다면 array보다는 collection을 사용하는편이 효휼적일 수 있습니다. 그런데 반대로 item을 추가하거나 삭제할 일이 전혀 없다면 collection보다는 array를 사용하는 편이 훨씬 더 나은 선택입니다. Array는 내부의 item을 인접하게 저장함으로서 memory를 훨씬 더 효휼적으로 사용하며 따라서 collection보다 나은 성능을 낼 수 있습니다.

collection에 관한 자세한 내용은 추후에 알아볼 것입니다.

5. 형변환과 type변환

Programming에서 서로다른 type간 변수의 값을 바꾸는 경우는 매우 흔한 경우입니다. 예컨데 문자열형식으로 들어온 data는 처음에는 string type으로 저장되지만 곧 필요에 따라 숫자나 날짜등으로 얼마든지 변환하여 취급되는 것입니다.

숫자역시 비슷하지만 엄밀히 다른 type인 경우에도 변환이 필요합니다. int에서 double로 변환하는 경우처럼 계산하고자 하는 목적에 따라 그 data역시 달라져야 하는 것입니다.

형변환은 곧 type변환을 의미하기도 하며 결국 같은 의미로 통용됩니다. 그리고 이러한 변환은 그 변환의 방식에 따라 암시적(implicit)변환과 명시적(explicit)변환으로 나눌 수 있는데 암시적 변환은 자동적으로 발생하는 것으로서 비교적 안전하게 변환이 이루어지며 변환결과에 따른 data손실이나 변경이 발생하지 않습니다. 반대로 명시적 변환은 개발자가 의도적으로 변환하는 것으로서 특히 숫자에서 소수의 정밀도에 따라 data의 손실이 발생할 수 있는데 이는 compiler에게 이러한 손실이 발생할 수 있음을 알고있고 그걸 감수할 준비가 되었음을 알려주는 것입니다.

1) Number type 에서의 암시적 형변환과 명시적 형변환

int값을 double값으로 변환하는 암시적형변환은 어떠한 data의 손실이나 변형도 발생하지 않기 때문에 안전하게 이루어질 수 있습니다.

아래 예제가 int형에서 double형으로 암시적 변환이 수행되는 사례를 나타는 것인데, int형 변수 i를 double형 변수 d에 할당하는 순간 암시적인 형변환이 발생합니다.

int i = 10;
double d = i; //암시적 형변환

Console.WriteLine(i);

그럼 반대는 어떨까?

이번에는 double형 변수 d를 먼저 값을 할당하여 선언한 뒤 int형 변수 i로 암시적형변환이 이루어지도록 아래와 같이 code를 작성합니다.

double d = 10.99;
int i = d;

Console.WriteLine(i);

위 상태에서 예제를 실행하려 하면 아래와 같은 오류가 발생할 것입니다.

error CS0266: Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?)

결론만 얘기하면 double형에서 int형으로의 암시적형변환은 불가능합니다. int보다 double자체가 더 넓은 범위의 값을 가질 수 있을 뿐만 아니라 int는 점이하의 소수부분 정보를 담을 수 없기 때문에 형변환과정에서 data의 손실이 발생할 수 밖에 없기 때문입니다. 따라서 이런 경우에는 개발자가 형변환을 직접 지정하는 명시적형변환을 수행해야 합니다.

명시적형변환은 변환하고자하는 type을 괄호를 사용해 아래와 같이 직접 지정해 주는 방식입니다.

double d = 10.99;
int i = (int)d;

Console.WriteLine(i);

분명히 알아야할건 위와 같은 경우는 어떻게든 작동은 하겠지만 data의 손실과 그에 따른 결과를 개발자가 직접 책임져야 한다는 것입니다. 특히 큰값을 가진 type의 변수를 작은 값을 가지는 type의 변수로 변환할때는 전혀 예상치 못한 엉뚱한 값으로 변환이 수행될 수도 있음을 염두해 두어야 합니다.

long l = 100;
int i = (int)l;

Console.WriteLine(i);

위 예제는 long값에 100을 할당한 뒤 이를 int변수로 형변환을 수행하고 있습니다. 이런 경우에는 long type이라 하더다도 int에 충분히 수용할 수 있는 100의 값을 변환하는 것이기 때문에 아무런 문제가 되지 않지만

long l = long.MaxValue;
int i = (int)l;

Console.WriteLine(i);

위와 같이 int범위를 넘어서는 매우 큰값에 대해 형변환을 수행하면 아마도 아래와 유사한 결과를 표시할 것입니다.

또는 아래와 같이 overflow를 발생시켜 엉뚱한 값을 표시할 수도 있는데

long l = 5_000_000_000;
int i = (int)l;

Console.WriteLine(i);

이것은 int형 값을 binary로 표현하는 과정에서 발생하는 결과입니다.

(1) Binary에서 음수를 표현하는 방식

'long.MaxValue'를 사용한 예제의 결과에서 i의 값은 -1이 됩니다. 이렇게 되는 이유는 음수를 표현할때 binary에서 첫번째 bit를 부호를 나타내는데 사용하기 때문입니다. 첫번재 bit가 0이면 양수, 1이면 음수를 의미합니다.

아래 예제는 이를 확인하기 위한 것으로 i의 값을 양수5부터 음수5까지 순회하면서 각각의 값을 binary로 표시하고 있습니다.

for (int i = 5; i >= -5; i--)
{
    Console.WriteLine($"{i} to bit => {i:B32}");
}

예제를 실행하면 다음과 같은 결과를 표시합니다.

예제에서 사용한 :B32는 32자리의 크기로 binary를 나타내기 위한 것입니다.

결과를 보면 모든 양수값에서 bit는 0으로 시작하며 모든 음수값에서 bit는 1로 시작함을 알 수 있습니다. 특히 -1값을 보면 모든 bit가 1임을 알 수 있는데 상기 예제에서 long의 Max값을 binary로 표현하면

long l = long.MaxValue;
Console.WriteLine($"{l} to bit => {l:B64}");

아래와 같이 되고

이를 int값으로 변환하게 되면 뒤의 1부분만 32bit로 들어가게 되므로 결국 예제의 i값은 -1이 됩니다. 즉, 큰값에서 작은값으로의 형변환시에 큰값의 bit가 버려지게 되는 것인데, 예를 들어 32bit int값을 16bit int값으로 형변환하게 되면 앞의 16bit에 해당하는 모든 bit가 버려지게 되고 나머지 16bit만 사용됩니다. 그리고 결국 여기에 해당하는 만큼의 값만이 남게 되는 것입니다.

5,000,000,000의 long값을 int로 변환하는 예제에서도 마찬가지입니다. 이러한 원리가 적용되면 결과적으로 707949866이라는 값을 표시하게 됩니다.

long l = 5_000_000_000;
int i = (int)l;

Console.WriteLine($"{l} to bit => {l:B64}");
Console.WriteLine($"{i:10} to bit => {i:B64}");

부호화된 수를 computer에서 표시하는 것과 관련해 더 자세한 사항을 알아보려면 아래 link를 참고하시기 바랍니다.
https://en.wikipedia.org/wiki/Signed_number_repr%EF%BB%BFesentations

2) System.Convert로 type변환하기

본래 type간 형변환은 비슷한류의 type안에서만 수행할 수 있습니다. 예를 들어 int는 byte나 long사이에서만 가능하며 class역시 동급이나 해당 class의 하위 class사이에만 가능합니다. 따라서 long을 문자열로 하거나 byte를 DateTime으로 변환하는 것은 암시적이든 명시적이든 불가능합니다.

이렇게 서로 다른 type간 변환을 수행하기 위해서는 조금 특별한 방법을 써야 하는데 그것이 바로 System.Convert를 사용하는 것입니다. System.Convert는 bool, DateTime, string등 뿐만 아니라 숫자관련 모든 type으로 부터 변환을 수행할 수 있습니다.

아래 예제는 System.Convert를 사용하여 변환을 수행한 것으로

long l = 1_000_000_000;
string s = System.Convert.ToString(l);

Console.WriteLine(s);

System.Convert의 ToString method를 통해 지정한 값을 문자열로 변환하고 있습니다. System.Convert는 이외 ToInt32나 ToBoolean등 다양한 변환 method를 가지고 있으므로 필요시에 적절한 method를 호출하여 사용할 수 있습니다.

변환을 말할때 흔히 Cast와 Convert가 많이 언급되는데 기본적인 개념은 동일하지만 Convert는 변환과정에서 overflow가 발생하면 이에 대한 예외를 발생시키지만 Cast는 예외대신 overflow를 허용한다는 차이가 있습니다.

(1) 반올림 규칙

실수를 정수형태로 형변환하는 경우는 소수점 이하 값을 어떻게 할지에 대한 결정이 필요한데, 이를 위해 적용되는 규칙이 존재합니다. 우리가 초등학생때 배운것을 생각해 보면 소수이하값이 .5이상이면 올림을, 그 보다 더 작은 값이면 내람을 하면 된다고 판단할 수도 있습니다. 물론 이치에 틀린말은 아니지만 이러한 방식은 경우에 따라 한쪽으로 올림이 몰리는 현상이 발생할 소지가 많습니다. 따라서 C#에서는 약간의 규칙을 적용하고 있습니다.

아래 예제는 C#에서 소수점이하값을 처리하기 위해 사용하는 규칙을 정확히 알아보기 위한 것으로서 몇개의 소수에 대한 변환을 수행하고 있습니다.

double[] values = { 2.49, 3.5, 4.51, -5.49, -6.5, -7.51 };

foreach(var item in values)
{
    Console.WriteLine(Convert.ToInt32(item));
}

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

결과를 보면 C#에서는 위에서 언급한 단순한 규칙을 따르고 있지 않다는 것을 알 수 있습니다. 예제에서 적용된 규칙을 살펴보면 우선 소수점값이 .5보다 낮으면 0으로 내림을 수행하고 .5보다 더 높으면 올림을 수행합니다. 여기까지는 별 다를바 없지만 만약 소수점이하값이 .5이고 정수부분이 음수라면 반올림을 수행하지만 정수부분이 양수라면 내림을 수행한다는 것을 알 수 있습니다. 이러한 규칙을 흔히 '은행가의 반올림'이라고 하며 반올림과 내림을 균등하게 교차시킬 수 있다는 이유로 선호되는 방식이기도 합니다. 다만 JavaScript와 같은 언어에서 처럼 '은행가의 반올림'규칙을 따르지 않는 것도 존재합니다.

(2) 반올림 규칙 조정하기

C#에서는 반드시 위와 같은 규칙만을 적용해야 하는 것은 아닙니다. 필요하다면 Math class의 Round method를 사용하여 이러한 규칙을 조정할 수 있습니다.

foreach(var item in values)
{
    Console.WriteLine(Math.Round(item, 0, MidpointRounding.AwayFromZero));
}

아래 예제는 위 예제에서 Round method를 통해 MidpointRounding.AwayFromZero option으로 반올림규칙을 조정한 것입니다. 위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

결과에서 보듯 소수점이하 .5를 포함해 그 이상인 값은 모두 반올림되었음을 알 수 있습니다.

3) 특정 type에서 string으로 형변환 하기

어떤 type에서 string으로 변환하는 경우의 대부분은 읽을 수 있는 형태로 type을 나타내기 위한 것입니다. 이를 위해 모든 type은 System.Object class에서 파생된 ToString이라는 method를 갖고 있습니다.

변수에서 ToString은 해당 변수의 값을 문자열로 나타내지만 어떤 type의 경우에는 ToString으로 나타낼만한 정보가 없기 때문에 대신 자신이 속한 namespace와 이름을 표시하기도 합니다.

아래 예제는 몇가지 변수를 선언해두고 각각 자신의 ToString method를 호출하고 있습니다.

int i = 10;
bool b = true;
object o = new();

Console.WriteLine(i.ToString());
Console.WriteLine(b.ToString());
Console.WriteLine(o.ToString());

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

그런데 위 예제는 사실 아래와 같이 ToString method를 생략할 수 있습니다.

Console.WriteLine(i);
Console.WriteLine(b);
Console.WriteLine(o);

특정 개체를 WriteLine method에 전달하면 암시적으로 string type의 형변환이 이루어지기 때문이며 따라서 명시적으로 ToString을 호출할 필요가 없습니다. 그러나 ToString method를 명시적으로 호출하면 string으로 발생하는 형변환의 boxing동작을 피할 수 있기 때문에 method를 호출하는 쪽이 성능면에서는 더 도움이 될 수 있습니다.

(1) Binary에서 string으로의 변환

Image나 동영상과 같은 media file은 그 자체가 binary로 이루어져 있는데 이러한 파일에 대한 전송과 저장은 아주 흔하게 발생합니다. 예를 들어 특정 image를 전송하고자 할때 binary자체의 bit를 그대로 보낼 수 있지만 bit를 있는 그대로 다룬다는건 생각보다 절차가 복잡하고 어려울 수 있습니다. 게다가 이기종간의 전송이라면 동일한 bit를 다르게 해석할 수 있다는 문제도 발생할 수 있습니다.

이러한 문제를 해결하기 위한 가장 안정적인 방식은 binary개체를 안정적인 문자열로 변환하여 처리하는 것이며 이때 가장 많이 사용되는 것이 바로 Base64 encoding입니다. Base64는 64개의 특정 문자집합을 사용해 임의의 bit data를 문자열로 변환하는 encoding scheme로서 data전송에 광범위하게 사용되는 방식입니다.

Base64를 사용하기 위해서는 Convert type을 사용해야 하며 Convert는 이를 위한 ToBase64String과 FromBase64String이라는 2개의 method를 갖고 있고 이 method를 통해 변환과 복원을 수행할 수 있습니다.

예제를 위해 우선 아래와 같이 byte배열 변수를 선언하고 이를 임의의 값으로 채워넣습니다.

byte [] b = new byte[128];
Random.Shared.NextBytes(b);

그런다음 각각의 개별값을 그대로 표시합니다.

for(int i = 0; i < b.Length; i++)
    Console.Write(b[i] + " ");

여기까지 예제를 실행하면 아래와 같은 결과를 볼 수 있습니다. 결과는 채워진 값에 따라 다르게 보일 수 있습니다.

기본적으로 위 결과는 int값을 10진수로 표시합니다. 따라서 만약 이를 16진수로 표시하고자 한다면 :X2와 같은 서식 code를 사용해야 합니다.

만약 위와 같은 byte배열 data가 image binary data라고 가정한다면 다음의 방법을 통해 base64 문자열로 변환할 수 있습니다.

string s = Convert.ToBase64String(b);
Console.WriteLine(s);

위 예제는 다음과 같은 결과를 표시합니다.

(2) URL에서 Base64 사용하기

Base64는 위와 같은 상황에서는 매우 유용하게 사용될 수 있지만 특정한 상황에서는 문제를 일으킬 수 있습니다. 특히 query string을 갖고 있는 URL을 처리하는 경우에는 +나 -같은 문자가 문제가 될 수 있는데 Base64에서 이러한 문자는 조금 특수하게 취급되고 있기 때문입니다.

따라서 URL의 경우 Base64Url이라고 하는 전용 scheme를 사용해야 합니다. 기본적으로는 Base64와 비슷하지만 URL에서 문제될 수 있는 몇가지 문자를 약간 다르게 사용함으로서 URL을 좀더 안전하게 생성할 수 있습니다.

.NET9 에서는 새로운 Base64Url class를 도입하였고 여기에서 URL data를 encoding하고 decoding하기 위한 최적화된 method를 제공하고 있습니다.

아래 예제에서는 특정 URL을 통해 Base64Url을 사용하여 URL을 encode하고 다시 decode한뒤 그 결과를 확인하고 있습니다.

using System.Buffers.Text;
using System.Text;

string originalURL = "http://...url?find=name+age";
byte[] urlBytes = Encoding.UTF8.GetBytes(originalURL);
string encodedURL = Base64Url.EncodeToString(urlBytes);
Console.WriteLine("Encode : " + encodedURL);

byte[] urlEncodeBytes = Base64Url.DecodeFromChars(encodedURL);
string encodedUrl = Encoding.UTF8.GetString(urlEncodeBytes);
Console.WriteLine("Decode : " + encodedUrl);

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

Base64와 관련된 더 자세한 사항은 아래 URL을 참고하시기 바랍니다.
https://base64.guru/standards/base64url

Base64URL | Base64 Standards | Base64

Base64URL Base64URL is a modification of the main Base64 standard, the purpose of which is the ability to use the encoding result as filename or URL address. The Base64URL is described in RFC 4648 § 5, where it is mentioned that the standard Base64 alphab

base64.guru

(3) 숫자나 날짜/시간 parsing하기위한 Parse 사용하기

문자열값으로 부터 숫자나 날짜 혹은 시간으로 변환하여 가져오는 경우는 아주 흔하게 발생하는 일입니다. 어떤 type에서 ToString method를 호출하는 것은 개체를 문자열로 나타내기 위한 것인데 이것과 반대되는 것이 바로 Parse입니다. 다만 Parse는 모든 type에 존재하지 않고 숫자나 DateTime과 같은 특정 type에만 존재합니다.

아래 예제에서는 문자열에서 각각의 Parse method를 통해 int값과 DateTime값을 가져오고 있습니다.

int i = int.Parse("100");
DateTime dt = DateTime.Parse("2026-02-02 10:30:20");

Console.WriteLine(i);
Console.WriteLine(dt);

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

DateTime형식의 값을 사용할때는 표준 날짜/시간 서식지정자를 사용할 수 있습니다.
https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings#table-of-format-specifiers

(4) TryParse method를 통해 예외 처리하기

Parse method를 편리하기는 하지만 만약 지정한 문자열에서 원하는 값으로 변환할 수 없는 경우에는 예외를 발생시키게 됩니다.

예를 들어 아래와 같은 경우입니다. int의 Parse를 통해 문자열을 int형으로 변환하려 하고 있지만 지정한 문자열은 숫자가 안니 문자열을 갖고 있습니다.

int i = int.Parse("abc");

먄약 위의 예제를 실행하려 하면 다음과 같은 예외를 보게 될 것입니다.

위와 같이 Parse에서 발생할 수 있는 예외를 적절하게 처리하려면 try ~ catch문을 사용하거나 더 간단하게는 TryParse method를 대신 사용할 수 있습니다. TryParse는 주어진 문자열을 원한는 type으로 변환을 시도하고 변환이 가능하다면 true를, 그렇지 않으면 false를 반환합니다. 예외를 발생시키는 것은 비교적 비용이 많이 드는 동작이므로 되도록이면 이를 피하고자 TryParse를 사용하는 것입니다.

아래 예제는 TryParse를 사용해 문자열값으로부터 int type으로 변환을 수행하고 있습니다.

if (int.TryParse("abc", out int i))
{
    Console.WriteLine(i);
}
else
{
    Console.WriteLine("failed!");
}

예제에서 사용된 out keyword는 TryParse method가 정상적으로 변환하는 작업을 수행했을때 그 결과값을 담아둘 변수를 지정하기 위한 것입니다.

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

이외에도 문자열값을 다른 type으로 변환하기 위해 System.Convert method를 사용할 수 있지만 변환에 실패하는 경우 예외를 발생시킵니다.

모든 TryParse method는 변환의 성공과 실패를 나타내기 위해 bool type의 값을 반환하며, 변환에 성공하는 경우 값을 담기위한 out 매개변수를 가집니다. 이러한 규칙은 모든 try method에 동일하게 적용됩니다.

6. 예외처리

.NET Application에서는 어떤 예기치 않은 문제가 발생하면 '예외(Exception)'을 발생시킬 수 있습니다. 이때 발생한 예외를 적절히 처리하는 것을 예외처리라고 하며, 어떤 언어에서는 error가 발생하면 그에 해당하는 error code를 대신 반환하기도 합니다. .NET은 error가 발생한 경우에 예외라는걸 통해서 문제점을 좀더 잘 살펴볼 수 있도록 지원하고 있습니다.

Error code를 사용하는 경우 해당 값에 따라 여러가지로 판단할 수 있을 것입니다. 예를 들어 값이 음수인 경우 무엇인가 잘못되었음을 알리는 것이지만 양수값인 경우 정상처리되었음을 알려주는 의미가 될 수도 있습니다. .NET에서도 일부 third-party library의 경우 result type을 자체적으로 정의하여 이러한 값의 의미를 더 잘 이해할 수 있도록 해주는 경우도 있는데 예외를 사용하는 것 보다 이러한 방식을 더 선호하는 경우도 있습니다.

Application에서 예외가 발생하면 thread는 중지됩니다. 이때 예외를 발생시킨 code를 try~catch문안에서 구현했다면 자체적으로 예외를 처리할 수 있습니다. 만약 그렇지 않은경우 해당 code를 호출한 상위 stack으로 예외를 던지게 되며 그 상위에서도 적절한 예외처리가 구현되어 있지 않으면 또 다시 그 상위로 예외를 던지는 동작을 계속 진행하게 됩니다. 그러다가 더이상 거슬로 올라갈 수 있는 상위 stack이 존재하지 않으면 그때 사용자에게 stack trace정보를 포함해 예외 message를 표시하고 Application전체를 종료시키게 됩니다. 잠재적으로 잘못된 상태의 Application을 불안하게 유지하는 것보다 이러한 방식으로 처리하는 것이 더 좋은 선택일 수 있습니다.

if문과 같이 조건을 확인하는 방식을 통해 예외를 발생시킬 수 있는 code의 작성을 최소화하는 것이 좋습니다. 물론 문제가 되는 code를 호출하는 상위 component에서 예외를 처리하도록 하는 것이 더 나은 선택일 수 있으므로 상황에 따라 잘 판단해야 합니다.

.NET9 부터 예외는 NativeAOT 예외처리 model을 기반으로한 새로운 방식을 사용하고 있으며 이를 통해 이전보다 더 나은 성능을 그대할 수 있게 되었습니다.

1) try ~ catch

어떤 code가 error를 유발할 가능성이 있으면 이를 try~catch문으로 감싸둘 수 있습니다. 예를 들어 문자열에서 숫자값을 읽어들이는 위의 예제의 경우에도 Parse method를 사용하면서 try~catch문을 사용할 수 있습니다.

try~catch는 try와 catch 2개의 부분으로 구성되는데 try문안에 있는 code가 기본적으로 실행되면서 예외가 발생한 경우에만 catch문안에 있는 code를 실행하게 됩니다.

Console.WriteLine("start");

string? s = Console.ReadLine();

try
{
    int i = int.Parse(s!);
    Console.WriteLine($"input value : {i}");
}
catch (System.Exception)
{
}

Console.WriteLine("end");

위 예제는 문자열값을 int값으로 읽어들이는 시도를 하고 있는데 이 구문을 try~catch로 감싸고 있습니다.

또한 예제는 'warning CS8600: Converting null literal or possible null value to non-nullable type.'이나 'warning CS8604: Possible null reference argument for parameter 's' in 'int int.Parse(string s)'.'과 같은 경고 message를 표시할 수 있는데 이는 .NET6 부터 nullable 참조 type을 허용하고 있기 때문입니다. 물론 위 code가 실제 사용자에게 배포되는 application수준의 code라면 이러한 경고를 무시해선 안되고 null인 경우에 대한 적절한 처리를 추가해야 합니다. 그러나 예제는 사용자가 아무런 값을 입력하지 않는 경우에도 공백을 반환하므로 실제 null이 되지 않을 뿐더러 null을 확인하는 추가적인 code를 추가하면 code를 더 복잡하게 만들 수 있어 이를 생략하고 있습니다.

(1) null-forgiving 연산자를 통해 경고 message억제하기

위 예제에서의 compiler 경고를 억제하려면 s문자뒤에 느낌표(!)문자를 붙여주면 됩니다.

string? s = Console.ReadLine();

try
{
    int i = int.Parse(s!);
    Console.WriteLine($"input value : {i}");
}
catch (System.Exception)
{
}

이때 !를 'null-forgiving 연산자'라고 합니다. null-forgiving 연산자는 runtime에서 아무런 영향도 주지 않지만 만약 null이 발생한다면 예외를 발생시킬 것입니다.

예제를 실행하고 숫자를 입력하면 아래와 같은 결과를 볼 수 있습니다.

이번엔 다시 예제를 실행하고 숫자가 아닌 문자를 입력합니다. 그러면 결과를 약간 다르게 표시될 것입니다.

예제가 실행된 후 try안에 구문에서 예외가 발생하면 별다른 message를 표시하지 않고 application이 정상적으로 종료된다는 것을 알 수 있습니다. 물론 이러한 동작도 나쁘지 않지만 예외가 발생하면 어떤 문제가 발생했지는 사용자에게 알려주는 것이 더 유용할 수 있습니다. 실제 사용자에게 배포되는 application의 경우라면 예외를 조용히 처리하는건 잠재적인 문제점을 숨기는 것에 불과하므로 당장에 예외를 사용자에게 보여주길 원하지 않거나 적절한 처리를 하지 않을 것이라면 log를 남겨두는것도 방법이 될 수 있습니다. 또는 예외를 상위로 던져 상위수준에서 발생한 예외를 처리하도록 하는 것도 좋은 방법입니다.

(2) 모든 예외 처리하기

발생할 수 있는 모든 type의 예외에 대한 정보를 가져오기 위해서는 catch에서 System.Exception type의 변수를 선언해야 합니다.

try
{
    int i = int.Parse(s!);
    Console.WriteLine($"input value : {i}");
}
catch (System.Exception ex)
{
    Console.WriteLine($"{ex.GetType()} - {ex.Message}");
}

위 예제는 예외가 발생한경우 해당 예외 type과 예외에 대한 message를 표시하도록 하고 있습니다.

예제를 실행한 후 abc와 같이 숫자가 아닌 문자를 입력하면 아래와 같은 예외 message를 볼 수 있습니다.

(3) 특정 예외만 처리하기

위 예제를 통해 우리는 숫자가 아닌 값을 입력하면 어떤 type의 예외가 발생할 수 있는지 알 수 있습니다. 발생가능한 예외의 type을 알면 해당 하는 예외가 발생했을때 사용자에게 좀더 도움이 될만한 정보를 제공해 줄 수 있을 것입니다.

위 예제에서 기존 catch (System.Exception ex)는 그대로 남겨두고 그 위에서 이전에 발생한 FormatException 예외를 아래와 같이 추가합니다. FormatException이 어떤 경우에 발생할 수 있는지 알고 있으므로 사용자에게 그에 맞는 안내 message를 다음과 같이 남겨 둘 수 있습니다.

try
{
    int i = int.Parse(s!);
    Console.WriteLine($"input value : {i}");
}
catch (System.FormatException)
{
    Console.WriteLine("The you entered is not a valid number.");
}
catch (System.Exception ex)
{
    Console.WriteLine($"{ex.GetType()} - {ex.Message}");
}

예제를 실행하고 이전 예제와 동일한 값을 입력하면 이번에는 다음과 같은 결과를 표시할 것입니다.

위 예제에서 System.Exception에 대한 catch를 제거하지 않고 남겨 두는 이유는 FormatException이외에 다른 예외가 발생하는 경우에 대한 대비입니다. 이때 위와 같이 여러 catch를 사용하고자 하는 경우에는 순서가 중요한데, 가장 구체적이며 발생할 가능성이 많은 예외를 위에 두고 System.Exception처럼 보편적인 예외는 가장마지막에 두어야 합니다. 그렇다고 이 순서를 크게 걱정할 필요는 없습니다. 어차피 순서가 잘못되면 compiler는 error를 표시하고 Application의 compile을 중단할 것이기 때문입니다.

모든 예외 type은 System.Exception으로 부터 상속되므로 System.Exception은 전체 예외 type에 대한 최상위 type이 됩니다.

다만 너무 많은 예외를 잡지 않도록 주의해야 합니다. 예외를 처리할 수 있는 더 많은 정보를 가진 상위의 call stack으로 예외를 전파시키는 것이 당장 예외를 처리하여 전파를 중단시키는 것 보다 더 나은 상황을 만들 수 있기 때문입니다.

(4) Catch에서 filter적용하기

catch부분에서는 when keyword를 사용하여 특정 조건에 대한 예외를 filter할 수 있습니다.

catch (System.FormatException) when (s.Contains("abc"))
{
    Console.WriteLine("Please enter a number, not a letter.");
}
catch (System.FormatException)
{
    Console.WriteLine("The you entered is not a valid number.");
}

위 예제에서는 동일한 FormatException에 대한 catch를 추가하면서도 when을 사용해 입력된 내용중에서 'abc'라는 문자열을 포함하는 경우로 한정하고 있습니다.

2) Overflow

이전에 형변환에 대해 언급할때 number type의 형변환시 예를 들면 long에서 int형으로 변환시에 본래 값에서 일부 data가 손실될 수 있음을 알 수 있었습니다. 그런데 변환대상이 되는 값이 저장될 type에 비해 너무 크다면 이때는 overflow가 발생하게 되고 예상치 못한 결과를 만들게 될 수 있습니다.

(1) checked

checked 구문을 사용하면 overflow 예외를 발생시킬 수 있습니다. 본래 overflow상황이 발생하면 성능적인 문제 때문에 일부 data가 손실되는 상황이 발생해도 결과값을 저장함으로서 별다른 오류없이 조용히 처리하지만 checked문은 overflow가 발생하면 이에 대한 예외를 던져주게 됩니다.

먼저 아래 에제를 보겠습니다. 예제는 int형변수에 int가 담을 수 있는 최대값을 저장한 후 +1을 하여 그 결과를 확인하고 있습니다.

int i = int.MaxValue;

Console.WriteLine(i);
++i;
Console.WriteLine(i);

예제를 실행하면 아래와 같은 결과를 표시할 것입니다.

실행결과를 보면 int최대값에서 +1을 하게 됨으로서 overflow가 발생하였고 그 결과 i의 값은 -값이 되었습니다.

아래 에제는 위 예제에서 checked문만 추가한 것입니다.

checked {
    int i = int.MaxValue;

    Console.WriteLine(i);
    ++i;
    Console.WriteLine(i);
}

예제를 실행하면 이번에는 다음과 같은 결과를 표시할 것입니다.

결과를 보면 예외를 통해 overflow가 발생하였음을 알 수 있습니다.

당연하지만 overflow예외의 경우에도 catch를 통해 잡아낼 수 있습니다.

try
{
    checked {
        int i = int.MaxValue;

        Console.WriteLine(i);
        ++i;
        Console.WriteLine(i);
    }   
}
catch(Exception ex)
{
    Console.WriteLine(ex.Message);
}

(2) unchecked

위에서 사용한 checked는 runtime에서 overflow가 발생한 경우 기본동작을 바꿔 예외를 발생시키도록 하기 위한 것입니다. 그런데 overflow는 compile단계에서 오류를 발생시키는 경우도 있습니다. 특히 VS2026과 같은 IDE에서 아래와 같이 overflow가 예상되는 구문을 작성했을때

int i = int.MaxValue + 1;

Console.WriteLine(i);
++i;
Console.WriteLine(i);

compiler는 compile을 시도하기 전에 다음과 같이 해당 구문에 문제가 있음을 알려주게 됩니다.

이러한 문제를 피하려면 unchecked라는 구문을 checked와 동일한 방식으로 다음과 같이 사용해야 합니다.

unchecked
{
    int i = int.MaxValue + 1;

    Console.WriteLine(i);
    ++i;
    Console.WriteLine(i);
}

이렇게 하면 더이상 compiler는 overflow에 대한 오류를 발생시키지 않을것입니다. 하지만 이러한 방법은 오류를 억제할 뿐 overflow는 여전히 발생할 수 있다는 점을 기억해야 합니다.

무차별 대입 공격 방어 도구 (Brute Force Attack Depend Tool) - Ban_Server

클리엘 — Fri, 16 Jan 2026 09:48:42 +0900

Remote Desktop의 경우 원격 port는 3389, MS-SQL Server의 경우 1433이 기본 port입니다. 그런데 server를 외부에서 접속 가능하도록 두면 이 2개 port에 대해서 무차별 대입 공격이 발생함을 알 수 있습니다.

For Remote Desktop, the default remote port is 3389, and for MS-SQL Server, it is 1433. However, if you leave the server accessible from outside, you can see that brute-force attacks occur on these two ports.

port번호를 바꾸면 일시적으로는 공격 빈도가 줄지만 시간이 지나면 다시 공격이 되살아나서 별 의미가 없습니다. 때문에 접속 가능한 IP만 제한적으로 열어두는 것이 제일 좋은데 만약 접속을 허용하는 IP만 특정할 수 없는 경우라면 해결 방법을 달리해야 합니다.

Changing the port number may temporarily reduce the frequency of attacks, but over time, the attacks will resume, making it largely ineffective. Therefore, the best approach is to restrict access to only specific IP addresses. If it is not possible to specify the exact IP addresses allowed for access, an alternative solution must be implemented.

무차별 대입 공격에 대응할 수 있는 방법이야 여러가지로 존재할테지만 그 방법중의 하나로 Ban_Server와 Ban_MSSQL을 소개하고자 합니다. Ban_Server는 Windows Server에서 원격제어를, Ban_MSSQL은 MSSQL Server의 전용port로 무단 접속을 시도하면 이와 관련된 Log를 만들때 이를 감지하고 공격자의 IP를 차단하는 역활을 수행합니다.

There are various methods to counter indiscriminate brute-force attacks, and among them, we introduce Ban_Server and Ban_MSSQL. Ban_Server detects unauthorized attempts to remotely control Windows Server and Ban_MSSQL detects unauthorized attempts to connect to the dedicated port of MSSQL Server. When creating logs related to these attempts, they perform the role of detecting them and blocking the attacker's IP address.

1. 설치방법

1. Installation Method

우선 Microsoft의 아래 homepage에서 Console Application용으로 .NET 10 Runtime을 내려받아 설치합니다.

First, download and install the .NET 10 Runtime for Console Applications from the Microsoft homepage below.

.NET 10.0 런타임 다운로드

.NET 10.0 런타임에는 기존 .NET 및 ASP.NET Core 애플리케이션을 실행하는 데 필요한 모든 것이 포함됩니다.

dotnet.microsoft.com

.NET 10 Runtime 설치를 하고 나면 아래 file을 내려 받고 file을 server의 임의폴더에 풀어줍니다.

After installing the .NET 10 Runtime, download the file below and extract it to any folder on the server.

Ban.zip

0.40MB

압축을 풀고나면 Ban_Server와 Ban_MSSQL 2개의 folder가 있는지 확인하고 각각의 폴더를 원하는 위치로 옮겨줍니다. 만약 REMOTE와 MSSQL을 모두 사용할 필요가 없다면 필요한 것만 사용하고 다른건 삭제해도 됩니다.

After unzipping, verify that the Ban_Server and Ban_MSSQL folders are present, then move each folder to your desired location. If you do not need to use both REMOTE and MSSQL, you may use only the necessary one and delete the other.

이제 ask Scheduler를 등록해야 하는데 우선 Remote Desktop에 대응할 Task Scheduler부터 등록합니다. 이를 위해 Control Panel -> Administrative Tools -> Task Scheduler를 실행하여 아래 제시된 방법으로 Task Scheduler를 등록합니다.

You must now register the Scheduler. Begin by registering the Task Scheduler for Remote Desktop. To do this, run Control Panel -> Administrative Tools -> Task Scheduler and register the Task Scheduler using the method described below.

오른쪽의 Create Task를 선택합니다.

Select Create Task on the right.

Name에 Ban_REMOTE를 입력하고 아래 Security Options에는 'Run whether user is logged on or not'을 선택합니다. 이때 Name은 해당 Task Scheduler가 어떠한 목적으로 만들어졌는지를 구분할 수 있을 정도면 다른 이름을 지정할 수도 있습니다.

Enter Ban_REMOTE in the Name field and select ‘Run whether user is logged on or not’ under Security Options. At this point, you can assign a different name to the Task Scheduler as long as it clearly indicates the purpose for which it was created.

다음으로 Trigger Tab으로 이동해 Begin the task에 'On an event'를 선택하고 Log에는 Security를 Event ID로는 4625를 입력합니다.

Next, go to the Trigger tab, select ‘On an event’ for Begin the task, and enter Security for Log and 4625 for Event ID.

Actions tab에서는 Action에 'Start a program'을 선택하고 Program/script에 Ban_Server.exe를 명시한 뒤 Start in (optional)에 Ban_Server.exe가 존재하는 folder를 지정합니다.

In the Actions tab, select ‘Start a program’ for Action, specify Ban_Server.exe in Program/script, and then designate the folder where Ban_Server.exe is located in Start in (optional).

이것으로 REMOTE(Ban_Server)에 대한 Task Scheduler을 완료하였습니다. 같은 방법으로 MSSQL에 관한 event로 등록해 줘야 하는데 위의 설정과정 대부분이 동일합니다. 다만 MSSQL의 경우 Trigger에서 Log를 Application을 잡고 Event ID를 18456으로 해야 합니다.

This completes the Task Scheduler setup for REMOTE(Ban_Server). You must register the event for MSSQL using the same method; most of the configuration steps above are identical. However, for MSSQL, you must set the Application in the Trigger to Log and the Event ID to 18456.

2. 사용방법

2. How to Use

압축을 풀어놓은 folder를 보면 jsconfig.json이라는 이름의 file을 볼 수 있습니다. 해당 file을 아래 내용으로 구성되어 있습니다.

When you unzip the folder, you will find a file named jsconfig.json. This file is structured as follows:

{
"FailedCount": 1,
"WhiteLists": []
}

FailedCount는 실패한 건수에 대한 대응입니다. 동일한 IP에 대하여 설정한 횟수 이상의 접속실패건이 발생하는 경우에만 해당 IP를 방화벽에 등록하여 차단을 수행하도록 합니다.

FailedCount corresponds to the number of failures. Only when the number of connection failures exceeds the set limit for the same IP address will that IP be registered in the firewall and blocked.

WhiteLists는 Ban_Server.exe가 예외로 둘 IP를 지정하는 곳입니다.

WhiteLists is where Ban_Server.exe specifies the IP addresses to be treated as exceptions.

{
"FailedCount": 1,
"WhiteLists": ["192.168.10.1", "192.168.10.2"]
}

따라서 만약 위와 같이 '192.168.10.1'과 '192.168.10.2'의 IP를 등록했다면 해당 IP에 대해서만 접속실패가 발생하더라도 차단방화벽의 IP로 등록하지 않습니다.

Therefore, if you have registered the IP addresses ‘192.168.10.1’ and ‘192.168.10.2’ as described above, even if access failures occur only for those specific IPs, they will not be added to the firewall's blocked list.

3. 기타

3. Other

Ban_Server는 Open source project이며 Git을 통해 source를 살펴보고 변경할 수 있습니다.

Ban_Server is an open-source project, and you can view and modify the source code via Git.

cliel/Ban_Server: 무차별 대입 공격 방어(Brute Force Attack Defend) (github.com)

GitHub - cliel/Ban_Server: 무차별 대입 공격 방어(Brute Force Attack Defend)

무차별 대입 공격 방어(Brute Force Attack Defend). Contribute to cliel/Ban_Server development by creating an account on GitHub.

github.com

※ 해당 프로그램 사용으로 인한 부작용에 대해서는 책임지지 않습니다.

※ We are not responsible for any adverse effects resulting from the use of this program.

※ json에서 FailedCount는 정확성을 보장하지 않습니다. FailCount를 3으로 하면 "3번 실패 시 작동한다."가 아니라 "3번 이상 실패 시 작동한다"쯤으로 해석해야 합니다. LOG를 읽고 program이 동작하는 시점에 다시 공격이 들어올 수 있는 등 여러 가지 예외 사항이 발생하므로 IP가 Block 완료될 때쯤 실제 공격은 3회 이상으로 이루어질 수 있습니다.

※ The FailedCount in JSON does not guarantee accuracy. Setting FailCount to 3 should be interpreted as “activates after 3 or more failures,” not “activates after exactly 3 failures.” Various exceptions can occur, such as attacks resuming while the program is processing logs. Therefore, by the time the IP is fully blocked, the actual attack may have occurred more than three times.

※ Ban_Server는 Windows Server상의 EventLog를 기반으로 동작합니다. Log가 많이 쌓아두면 그 만큼 처리하는데 시간이 오래 걸릴 수 있으며 Log의 관리특성에 따라 원하는 방향으로 프로그램이 동작하지 않을 수 있기 때문에 적절한 관리가 필요합니다.

※ Ban_Server operates based on the EventLog on Windows Server. If logs accumulate excessively, processing may take longer, and depending on log management characteristics, the program may not function as intended. Therefore, proper management is required.

[C# 14 / .NET 10] C# 14

클리엘 — Mon, 1 Dec 2025 17:38:04 +0900

이제 본격적으로 C#에 관한 전반적인 관한 내용을 다뤄보고자 합니다. C#에 대한 여러 기초 사항들을 살펴보고 문법을 사용해 필요한 구문을 작성하며 일반적으로 사용되는 여러 어휘들도 같이 알아볼 것입니다.

1. C#의 표준

몇 해에 걸쳐 Microsoft는 C#의 몇 가지 Version을 ECMA 표준 기관에 제출하였고 2014년 C#을 Open Source화 하였습니다. 이와 관련된 표준 문서는 아래 link에서 확인하실 수 있습니다.

https://learn.microsoft.com/en-us/dotnet/csharp/specification/

Specifications - ECMA specification and latest features.

Read the detailed specifications for the C# language and the latest features. The specifications are the definitive source for the behavior of the C# language.

learn.microsoft.com

ECMA표준 이외에 GitHub Repository에서도 C#을 공개적으로 만들기 위한 여러 가지 들을 살펴볼 수 있습니다.

C# 언어 설계	https://github.com/dotnet/csharplang
Compiler 구현	https://github.com/dotnet/roslyn
언어표준	https://github.com/dotnet/csharpstandard

2. C# Compiler Version

Roslyn은 C#과 VB.NET을 위한 Compiler를 말하며 .NET SDK의 일부분으로 배포되었고 F#에는 적용되지 않습니다. 일반적으로는 가장 최신의 Compiler를 사용하게 되지만 만약 다른 Version의 Compiler를 사용하고자 한다면 그에 해당하는 .NET SDK가 반드시 설치되어 있어야 합니다.

.NET SDK	Compiler Version	C# 언어 Version
1.0.4	2.0-2.2	7.0
1.1.4	2.3-2.4	7.1
2.1.2	2.6-2.7	7.2
2.1.200	2.8-2.10	7.3
3.0	3.0-3.4	8.0
5.0	3.8	9.0
6.0	4.0	10.0
7.0	4.4	11.0
8.0	4.8	12.0
9.0	4.12	13.0
10.0	5.0	14.0

.NET Application을 생성할 때 일반적인 .NET Version말고도 .NET Standard를 지정할 수 있는데 이런 경우 각 .NET Standard의 Version에 따라 기본 C#언어 Version도 달라집니다.

.NET Standard	C#
2.0	7.3
2.1	8.0

상술했듯이 특정 Compiler Version을 사용하려면 해당 Compiler를 포함하는 .NET SDK가 설치되어 있어야 합니다. 다만 이전 .NET Version을 Target으로 하는 Project를 생성한 경우 필요하다면 최신 Version의 Compiler를 사용하는 것은 가능합니다. 예를 들어 .NET 10 SDK를 설치했다면 .NET 8을 대상으로 하는 Project라도 C# 14의 언어기능을 사용할 수 있습니다.

1) 설치된 SDK Version 확인하기

현재 PC에서 사용가능한 .NET SDK와 C# Compiler Version을 확인하고자 한다면 아래 명령을 사용할 수 있습니다.

dotnet --version

위 결과로 나온 10.0.100을 보면 아직 초기 .NET SDK Version이며 어떠한 Bug수정이나 기능적인 변화가 없음을 알 수 있습니다.

2) 원하는 Compiler Version 사용하기

일반적인 경우 사용되는 Compiler Version은 현재 설치된 .NET SDK의 Compiler Version이 사용됩니다. 만약 .NET 14 SDK를 설치한 상태에서 이 후 .NET 14.1 SDK를 설치했다면 Compiler 역시 자체 Version으로 교체될 것입니다. 다만 언어 Version의 경우에는 SDK가 정한 기본 Version이 사용될 수 있는데 만약 특정 언어 Version을 사용해야 하는 경우라면 Project file에 아래와 같이 LangVersion요소를 추가해 줘야 합니다.

<LangVersion>14.1</LangVersion>

이때 LangVersion에서는 상황에 따라 다음과 같은 값을 지정해 줄 수 있습니다.

<LangVersion>	의미
9, 10, 11, 12, 13, 14..등등	지정한 언어 Version이 사용됩니다.
latestmajor	가장 높은 major 번호의 Version이 사용됩니다.
latest	가장 높은 major와 minor 번호의 Version이 사용됩니다. 만약 2026년에 14.1이 Release된다면 해당 Version이 사용될 것입니다.
preview	가능한한 가장 높은 version의 preview를 사용합니다. 예를 들어 2026년말 .NET 11 Preview 6를 설치했다면 해당 Version이 사용될 것입니다.

Microsoft는 아마도 2026년 초에 .NET 11의 첫 번째 Preview version을 C# 15 Compiler와 함께 Release 할 수도 있습니다. 이 시기에 .NET 11 SDK Preview를 설치하게 되면 이를 통해 Project를 생성하고 C# 15의 새로운 기능들을 사용해 볼 수 있습니다.

다만 이런 경우 위에서 설명드린 <LangVersion>을 Project file(.csproj) 아래와 같이 설정하여야 합니다.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net11.0</TargetFramework>
    <LangVersion>preview</LangVersion>
  </PropertyGroup>
</Project>

하지만 Preview는 어디까지나 Preview이므로 이를 Product환경에서 사용해서는 안됩니다. Microsoft는 Preview를 개발자를 통해 feedback을 얻기 위한 목적으로 공개할 뿐 공식적인 지원을 제공하지 않습니다.

3) Compiler 판올림하기

.NET SDK 10을 설치했다면 C# 14 Compiler만을 사용할 수 있지만 다른 Version의 .NET SDK를 추가로 설치한다면 해당 SDK의 C# Compiler 역시 사용할 수 있을 것입니다. 따라서 만약 2026년에 .NET SDK 11이 나오고 이를 설치한다면 C# 14와 15 Compiler를 사용할 수 있는 환경이 갖춰지게 됩니다.

새로운 Project를 생성하는 것은 물론이고 기존 Project의 Version을 올리는 것 역시 가능한데 예를 들어 .NET 10을 대상으로 한 Project가 있고 이 상태에서 .NET SDK 11을 설치했다면 Project file의 아래와 같은 설정을 통해 해당 C# Version을 올려줄 수 있습니다.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <LangVersion>15</LangVersion>
  </PropertyGroup>
</Project>

예제를 보면 TargetFramework에서 .NET의 Version을 .NET 10로 유지하고 있고, LangVersion을 통해 C#언어의 Version만 15로 설정해 주는 걸 확인할 수 있습니다. .NET 10은 꾸준히 Update를 지속한다면 2028년 11월까지 지원되므로 C#언어의 Version만 변경하고 SDK자체의 Version은 기존상태를 계속 유지할 수 있습니다. 향후 .NET SDK 11을 사용해 Project를 Build 하고자 하는 경우에도 LangVersion설정은 변경해 줄 필요가 없습니다.(.NET SDK 11을 대상으로 하는 신규 Project의 경우에는 당연히 최신 Version이 기본적으로 사용되므로 따로 별도의 필요하지 않습니다.)

일부 C# 언어기능은 .NET SDK의 Library에 의존성을 갖고 있을 수 있습니다. 따라서 위 예제에서처럼 TargetFramework의 값을 이전상태로 유지하면서 LangVersion만 최신 C# 언어 Version으로 변경하는 경우 해당 Version의 새로운 언어기능을 사용하지 못하는 경우가 생길 수 있습니다. 예를 들어 C# 11에서 도임된 required keyword는 .NET 7에서만 가능한 새로운 Attribute를 필요로 하기 때문에 하위 SDK Version인 .NET 6에서는 사용할 수 없습니다. 이런 경우 Compiler는 지원하지 않는 기능을 사용하는 것에 대한 경고 알림을 표시할 수 있습니다.

2. C# 문법 익히기

C#의 문법과 어휘에 대한 기본을 익혀보기 위해 간단한 예제를 만드는 것으로 시작해 보겠습니다. C#의 문법은 크게 구문과 block으로 나눌 수 있으며 Code에 대한 설명을 위해 주석문을 사용할 수 있습니다.

1) 구문

우리의 일상적인 언어에서 문장은 여러 단어와 문구로 이루어지며 마침표로 문장의 끝을 맺습니다. 단어가 나열되는 순서 또한 문장에서 중요하게 작용하는데 한국어와 달리 대부분의 Programming언어는 영어권의 영향을 받으므로 영어와 비슷한 순서가 적용됩니다.

C#에서 문장의 끝은 semicolon으로 나타내며 단어처럼 여러 Type과 변수, 그리고 표현식으로 이루어집니다. 예를 들어 아래 예제에서 int는 Type이며 i는 변수, '10 + 20'은 표현식에 해당합니다.

int i = 10 + 20;

여기서 표현식은 다시 10과 20이라는 피연산자와 +라는 기호의 연산자로 나누어 볼 수 있습니다. 이때 연산자와 피연산자의 순서는 그 의미와 결과가 달라질 수 있으므로 매우 중요한 부분에 해당합니다.

(1) 주석

주석은 Code를 설명하기 위한 가장 주된 방법이자 오래전부터 사용되어 온 고전적인 방법으로서 제삼자가 Code를 읽을 때 Code의 흐름을 이해하기 위한 주요 수단으로 활용됩니다. 심지어 Code를 작성한 본인도 시간이 흐르면 자신의 Code를 잊어버리게 되는데 '주석'은 여기서 기억을 상기시키는데 필요한 History로도 사용될 수 있습니다. 자신의 Code를 잊어버린다는 말은 선뜻 이해하기 어려울 수 있지만 Code를 작성한 개발자 본인아라고 하더라도 시간이 지나면 그때의 의도와 기억을 되찾지 못하는 경우가 대부분입니다. 자신의 기억력을 자신하지 마십시오.

주석이 Code를 설명하기 위한 주된 방법이기는 하지만 유일한 방법은 아닙니다. 의미가 부여된 변수나 Method명, 단위 Test작성, Project과정에서의 여러 가지 산출물등 Code를 설명하는 데 사용되는 방법은 여러 가지가 있을 수 있습니다.

주석중에는 slash 3개로 시작하는 XML주석이라는 것이 존재합니다. 이러한 주석은 Code를 설명하기 위한 다양한 방법으로 활용될 수 있는데 XML주석에 관한 자세한 사항은 추후에 알아볼 것입니다.

주석중 한 줄 주석은 아래와 같이 slash 2개로 시작하며 Compiler는 //를 만나면 그 줄 전체를 무시하게 됩니다.

//덧셈 계산
int i = 10 + 20;

여러 Line에 걸쳐진 주석을 작성하려면 주석의 처음을 '/*'로 시작하고 끝을 '*/'로 끝내야 합니다.

/*
    아래 Code는
    덧셈 계산을 수행합니다.
*/

흔한 경우는 아니지만 위와 같은 주석방식은 Code의 가운데에 주석을 끼워 넣는 경우에도 사용될 수 있습니다.

int i = /* 표현식 부분 */ 10 + 20;

Method나 변수의 의미론적인 명명방식과 class의 Encapsulation 등은 그것 자체로 문서화의 역할을 수행할 수 있습니다. 실제 주석을 사용하는 경우에도 너무 많은 주석은 오히려 Code를 이해하는데 방해가 되는 경우도 있으니 적당한 선을 유지하는 것이 좋습니다.

설명하는 목적 이외에 Code자체를 주석화하여 작동하지 않도록 하거나 주석된 Code를 다시 원복 시키는 경우도 있습니다. 이럴 때는 주석문으로 지정할 부분을 Code Editor에서 선택한 뒤 VS2026에서 Edit -> Advanced -> Comment Selection을 선택해 주석화 하거나 Uncomment Selection을 선택해 주석을 취소할 수 있습니다. VSCode라면 Edit -> Toggle Line Comment나 Toggle Block Comment로 동일한 동작을 수행할 수 있습니다. Menu사용할 통한 주석동작은 //을 추가하는 것과 //을 제거하는 것이 전부입니다.

(2) Block

우리말에서 문단은 새로운 행을 기점으로 나타내지만 C#에서는 중괄호({})를 사용한 Code의 Block을 통해 나타냅니다.

특히 C#은 뭔가에 대한 시작점을 정의하는 것으로 사용되는데 예를 들어 구조체, Namespace, Class, Method는 물론 foreach와 같은 구문에서도 사용될 수 있습니다. Namespace나 Class, Method에 대한 자세한 사항은 추후에 자세히 알아볼 테지만 이들에 대해 간략히 설명하자면 다음과 같이 정의할 수 있습니다.

Namespace	관련있는 여러 Class 및 Type들을 Group화하기 위해 사용됩니다.
Class	Method를 포함해 개체의 Member들을 포함한 것으로 Type을 나타내는데 사용됩니다.
Method	개체가 가질 수 있는 동작을 구현하는데 사용됩니다.

VS2026이나 VSCode와 같은 Editor에서는 왼쪽여백에 화살표모양을 Click 함으로써 하나의 Code Block전체를 접거나 펼 수 있는 편리한 기능을 제공하고 있습니다. 화살표가 내려가면 Block이 펼쳐진 상태를 의미하고 오른쪽으로 향하고 있으면 Block이 접혀 있는 상태를 의미하는데 해당 화살표모양은 평소에는 숨겨져 있지만 mouse pointer를 여백에 가져대 대면 자동으로 표시됩니다.

(3) Region

특정한 Code의 영역을 묶어 이를 지역화할 수도 있습니다. 이때 의미 있는 이름을 붙여줄 수 있는데 상술했던 Code Block의 접고 펴는 기능은 Region에서도 동일하게 적용됩니다.

지역화는 #Region으로 시작해 #endregion으로 끝나며 Editor는 이 사이에 Code를 지역화로 묶어주게 됩니다.

(4) Block Style

C#에서 Block는 여는 중괄호와 닫는 중괄호를 사용하는 괄호 Style을 사용하며 각각 독립적인 Line에 위치하면서 동일한 들여 쓰기 수준을 갖습니다.

static void Main(string[] args)
{
    Console.WriteLine("Hello, World!");
}

또는 개발자의 Style에 따라 아래와 같이 구문의 정의가 끝나는 지점에 여는 중괄호를 배치하는 약간 다른 Style을 사용하기도 합니다. Method나 Class를 정의하는 경우에는 잘 없지만 하위의 특정 구문을 작성하는 경우 아래의 Style이 많이 사용됩니다.

static void Main(string[] args)
{
    if (1 == 1) {
        Console.WriteLine("Hello, World!");
    }
}

어떤 Style을 사용하든 전혀 문제 될 것은 없으므로 선호하는 방식을 선택해 사용하면 됩니다.

Microsoft에서 제시하는 공식적인 Coding Style은 아래 Link에서 찾아볼 수 있습니다.
https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions

다만 team단위개발에서 도입하는 특정 Style이 있다면 그걸 따라가는 방식도 필요합니다. 조직의 규칙이 적용되는 경우가 아니라면 어떤 식으로든 일관된 방식을 고수하는 것이 좋습니다.

Microsoft의 공식문서를 살펴보변 대부분 위 규칙 중 전자의 규칙을 사용한다는 것을 알 수 있습니다.

(5) 공백을 사용한 Code 서식화하기

공백의 개념은 Space를 포함해 Tab이나 개행문자등을 포함합니다. 그리고 Compiler는 이러한 공백문자를 무시하기 때문에 Code작성 시 서식화에 공백을 자유롭게 사용할 수 있습니다.

예를 들어 아래 예제에서의 3개 구문은 모두 동일합니다. Code에서 공백을 사용한 Style만 다를 뿐 변수명과 표현식이 모두 동일하기 때문입니다.

int i = 10 + 20;

int i=10+20;

int
i
=
10
+
20
;

위 예제는 모두 동일한 변수명인 i를 사용하고 있기 때문에 변수병을 변경하지 않는 이상 같은 Block안에 해당 구문이 모두 존재하는 것은 불가능합니다.

사실상 위 예제에서 공백이 들어가야 할 부분은 int라는 type명과 변수명 안 i사이뿐입니다. 만약 이 부분을 아래와 같이 작성한다면

inti...

Compiler는 어디가 Type이고 어디가 변수명인지를 구분할 수 없기 때문에 오류를 발생시킬 것입니다.

C#의 공백에 대한 더 자세한 사항은 아래 link를 참고하시기 바랍니다.
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#634-white-space

Lexical structure - C# language specification

This chapter explains the lexical grammar, and the syntactic grammar of the C# language.

learn.microsoft.com

2) 어휘

C#의 어휘는 keyword, 상징문자, type으로 구성됩니다.

여기서 keyword라 함은 사전에 특정 용도로 정의된 것을 말하는 것으로 이들 keyword는 변수명이나 Method이름과 같은 용도로는 사용할 수 없습니다. C# Code작성 시 자주 사용되는 keyword로는 using, namespace, class, static, int, string, double, bool, if, switch, break, shile, do , for, foreach, this, true, false 등이 있습니다.

this Keyword는 현재 개체의 instance를 참조하거나 개체의 생성자를 호출하고 indexer를 정의하는 등 여러 가지 용도로 사용될 수 있습니다. 더 자세한 사항은 추후에 자세히 알아볼 것입니다.

상징문자의 경우 ", ', +, -, *, /, %, @, $등이 있으며 괄호문자도 포함됩니다.

괄호의 경우에는 아래 4가지 문자가 사용되며 각각의 용도가 정해져 있습니다.

()	Method를 호출하고 표현식이나 조건을 정의하며 type간 변환을 수행하는데도 사용됩니다.
{}	Block을 정의하거나 개체 또는 Collection의 초기화를 수행합니다.
[]	Array나 Collection상에서 특정 Item에 접근하거나 Code에 Attribute를 적용하는데도 사용됩니다.
<>	Generic에서 Type을 정의하는데 사용되며 XML이나 HTML에서도 사용됩니다. 또한 표현식에서 작다(<), 크다(>)를 나타내는 용도로도 사용됩니다.

이외에 특정한 상황에서만 특별한 의미로 사용되는 like, or, not, record, init와 같은 keyword도 존재합니다.

C# keyword는 모두 소문자입니다. 자신만의 Type을 만드는 경우에도 모두 소문자를 사용할 수 있지만 실제로 그렇게 하는 것은 권장하지 않습니다. 아마다 향후에 새롭게 만들어지게 될 keyword 때문에 그런 것으로 보입니다. 실제로 자체 Type에 소문자를 사용하는 경우 Compiler는 'Warning CS8981'경고 Message를 표시할 수 있습니다.

Keyword는 이미 예약된 것으로 사용할 수 없지만 꼭 그렇게 해야 한다면 keyword앞에 '@'문자를 접두사로 붙여 사용할 수 있습니다.

int @class = 10;

그러나 위와 같은 방식은 code를 읽는 것에도 혼란을 초래할 수 있기 때문에 여전히 권장되지 않습니다.

3) Namespace

C#에서 namespace는 서로 관련 있는 class, interface, struct, enum, delegate 등을 group 하여 모은 것으로 이를 통해 동일한 명칭에 대한 충돌을 방지하고 code를 더욱 간결하게 작성할 수 있도록 합니다.

Namespace는 또한 일종의 type에 대한 주소의 역할을 수행하기도 하는데, 예를 들어 System.Console.WriteLine이라면 Compiler는 WriteLine이라는 method를 System namespace안에 있는 Console type에서 찾게 됩니다. 하지만 WriteLine method를 작성하기 위해 매번 System.Console.WriteLine Code를 작성할 수는 없으므로 .NET 6.0까지는 cs file상단에

using System;

같이 namespace를 선언함으로써 compiler에게 자신의 namespace가 존재하지 않는 type에 대해서는 System namespace를 찾아볼 수 있도록 하였습니다. 따라서 Code작성 시

Console.WriteLine(....)

만을 작성해 줄 수 있는 것입니다.

위에서 처럼 using System을 사용하는 경우 이를 namespace import라고 표현합니다.

(1) 암시적인 전역 namespace import

일반적으로 모든 .cs file은 각각 저마다 내부 code에서 필요로 하는 namespace를 import 하기 위한 using구문을 필요로 했습니다. 그런데 System과 System.Linq 같은 어떤 namespace들은 code를 작성하기 위해 필요한 아주 기본적인 namespace들이었고 따라서 project내의 거의 대부분의 cs file이 몇 줄에 걸친 동일한 using문이 작성되어야 했습니다. 심지어 어떤 경우에는 수십 가지의 namespace를 import 하기 위해 그만큼 많은 using문이 작성되는 경우도 있습니다.

이러한 문제를 보완하기 위해 C# 10부터는 새로운 keyword를 도입하였고 .NET SDK 6에서는 공통적으로 사용되는 namespace import를 간소화하기 위한 project 설정을 도입하게 되었습니다. 새로운 keyword는 'global using'문으로 해당 keyword를 사용하여 하나의 file에서만 namespace를 import 하면 이 효과가 project 전체 모든 cs file에 적용되기 때문에 각각의 cs file마다 반복적인 using문을 사용할 필요가 없게 되었습니다. 'gloabl using'문을 사용할 수 있는 file에는 제한이 없으므로 극단적으로 Program.cs file에도 사용할 수 있으나 GlobalUsings.cs와 같은 별도의 분리된 file을 생성하여 여기에서 아래와 같이 공통적으로 사용되는 namespace를 import 하는 것이 좋습니다.

global using System;
global using System.Linq;
...

.NET 6나 이후를 target으로 하는 모든 project는 C# 10부터의 compiler를 사용하게 됨으로써 기본적으로 obj/Debug/netXX.0 folder안에서 [Project명].GlobalUsings.g.cs file을 생성하게 됩니다. 그리고 이를 통해 System과 같은 일부 namespace의 암시적인 전역 import를 생성하게 됩니다. 이때 대상 namespace는 SDK에 따라 달라질 수 있습니다.

SDK	Implicitly imported namespaces
Microsoft.NET.Sdk	System System.Collections.Generic System.IO System.Linq System.Net.Http System.Threading System.Threading.Tasks
Microsoft.NET.Sdk.Web	Microsoft.NET.Sdk에 추가로 System.Net.Http.Json Microsoft.AspNetCore.Builder Microsoft.AspNetCore.Hosting Microsoft.AspNetCore.Http Microsoft.AspNetCore.Routing Microsoft.Extensions.Configuration Microsoft.Extensions.DependencyInjection Microsoft.Extensions.Hosting Microsoft.Extensions.Logging
Microsoft.NET.Sdk.Worker	Microsoft.NET.Sdk에 추가로 Microsoft.Extensions.Configuration Microsoft.Extensions.DependencyInjection Microsoft.Extensions.Hosting Microsoft.Extensions.Logging

실제 작성된 import file을 확인해 보기 위해 이전에 만든 Project를 VS2026으로 열어준 뒤 Solution Explorer에서 'Show All Files'button을 눌러 bin과 object folder가 표시되도록 합니다. 그리고 표시된 obj folder에서 Debug->net10.0순서로 열어 GlobalUsings.g.cs file을 찾아 해당 file을 열어봅니다.

GlobalUsings.g.cs file은 file앞에 Project명이 따라옵니다. 따라서 예제의 경우 'ConsoleApp1.GlobalUsings.g.cs' file이 되는데 설명에서는 'ConsoleApp1.'까지를 생략하였습니다.

GlobalUsings.g.cs file명에서 g는 'generated'를 의미합니다.

이러한 file은 .NET 6 이후를 대상으로 한 project를 생성하는 경우 compiler에 의해 자동적으로 생성되는 file로서 System을 포함해 몇 가지 기본적인 namespace의 import를 구현하고 있음을 알 수 있습니다.

만약 상기 namespace에 더해 추가적으로 import 하거나 필요 없는 namespace를 제거하고자 한다면 Solution Explorer에서 Project명을 double click 하여 Project file을 열고 여기에 아래와 같이 조정하고자 하는 namespace를 용도에 맞게 지정해 주면 됩니다.

예제의 ItemGroup과 비슷하게 ImportGroup이라는 요소도 존재하지만 정확히 ItemGroup을 사용해야 하므로 ImportGroup과 혼동해서는 안됩니다.

예제에서 Using Remove는 namespace의 제거를 의미하며, Static은 namespace의 정적 import를, Alias는 별칭을 지정하는 속성입니다.

위에서 처럼 필요한 namespace를 지정한 뒤 file을 저장하고 GlobalUsings.g.cs file을 다시 열어보면 아래와 같이 file의 내용이 변경되어 있음을 알 수 있습니다.

// <auto-generated/>
global using System;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;
global using System.Net.Http;
global using System.Threading.Tasks;
global using Env = System.Environment;
global using static System.Console;

위 결과에서 처럼 System.Environment는 Env라는 별칭이 지정되었으므로 아래와 같이 Env별칭을 통해 namespace의 type을 바로 사용할 수 있습니다.

WriteLine(Env.MachineName);

WriteLine 역시 상기에서 Sytem.Console을 정적 import 하였으므로 Console을 사용하지 않고 WriteLine method를 호출하는 것이 가능합니다.

자동으로 생성되는 file을 사용하기보다 직접 전역 import를 수행하는 file을 만들어서 사용하고자 하는 경우 처럼 필요하다면 암시적인 전역 import기능을 사용하지 않도록 설정할 수도 있는데 이렇게 하려면 Project file에서

<ImplicitUsings>enable</ImplicitUsings>

부분을 삭제하거나 혹은 아래와 같이 enable대신 disable로 지정해 주면 됩니다.

<ImplicitUsings>disable</ImplicitUsings>

4) Method

Method는 실질적으로 Application의 동작을 구현하는 부분입니다. 예를 들어 예제를 통해 계속 봐왔던 WriteLine도 Console에 Message를 표시하는 동작을 실행하는 것으로서 우리가 목표로 하는 대부분의 기능이 이러한 Method를 통해 이루어집니다.

Method는 호출되는 방식에 따라서도 그 동작이 달라질 수 있습니다. 예를 들어 아래와 같은 경우

Console.WriteLine();
Console.WriteLine("abcdefg");
Console.WriteLine("number : {0}", 100);

첫 번째 호출은 빈 공백을 표시하고 두 번째는 'abcdefg'라는 message를 표시하며 세 번째는 'number : 100'이라는 message를 표시합니다. 이렇게 Method를 다양하게 호출하는 것을 overloading이라고 하는데 이와 관련해서는 추후에 자세히 다뤄볼 것입니다.

5) 식별자

식별자라 함은 어떠한 대상의 이름으로서 C#에서는 type, 변수, field, 속성등을 정의할 때 이를 구분하는 특정한 명칭을 부여하게 됩니다.

예를 들어 우리가 'Car'라는 type을 만들면 그 안에 'Engine'이라는 field나 속성을 만들 수 있습니다. Airplan, Train과 같은 것들도 마찬가지로 특정한 개체를 참조하기 위한 식별자로 사용될 수 있을 것입니다. 여기서 중요한 것은 C#자체적으로는 어떠한 type도 정의하지 않는다는 것입니다. 단지 int나 string과 같이 특정 type에 대한 별칭의 keyword만 가지고 있을 뿐이며 이 마저도 현재 platform상에서 제공되는 type을 나타내기 위한 것일 뿐입니다.

C#이라는 언어는 .NET을 떠나 독립적으로 존재할 수 없는 언어이며 .NET상에서 동작하는 몇 가지 언어 중 하나에 불과합니다. 누군가가 전혀 다른 type을 가진 다른 paltform용으로의 C# compiler를 만들 수도 있겠지만 사실상 C#의 platform은 .NET이라고 할 수 있으며 .NET에서 System.Int32와 같이 수많은 type을 제공하고 있고 C#에서는 이렇게 제공된 System.Int32 type을 참조하기 위해 int라는 별칭을 사용하는 것입니다.

Type이라 함은 흔히 class로 오해하기 쉬운데 C#에서 말하는 type은 class뿐만 아니라 struct, enum, interface, delegate 등 다양하게 존재할 수 있습니다. 실제로 C#에서 쓰이는 string은 class에 해당하지만 int는 구조체(struct)에 해당합니다.

(1) 관련 예제로 Type 살펴보기

간단한 Console app을 통해 C#에서 사용되는 type(method를 포함해)이 얼마나 있는지를 알아보도록 하겠습니다. 아래 예제 code는 내부적으로 사용되는 type을 확인하기 위해 reflection이라는 방법을 사용하고 있는데, 시간이 지나면서 모두 이해할 수 있게 될 것이므로 지금은 code자체가 어떻게 동작하는지 정확하게 이해하지 않아도 됩니다.

Console App Project를 생성한 뒤 Program.cs의 모든 구문을 삭제하고 reflection을 사용하기 위한 namespace를 import 합니다.

using System.Reflection;

원한다면 상기 namespace를 global using을 통해 import 할 수도 있겠지만 예제에서는 단 하나의 file에서만 사용할 것이므로 예제와 같이 개별적으로 import 하여 사용할 것입니다.

그리고 아래와 같이 구문을 작성하여 각각의 Assembly가 가진 Method와 type의 수를 확인하도록 합니다.

using System.Reflection;

Assembly sampleApp = Assembly.GetEntryAssembly()!;

foreach (AssemblyName assName in sampleApp.GetReferencedAssemblies())
{
    Assembly ass = Assembly.Load(assName);

    int methodCount = 0;

    foreach (TypeInfo t in ass.DefinedTypes)
    {
        methodCount += t.GetMethods().Length;
    }

    Console.WriteLine("{0:N0} types and {1:N0} methods in {2} assembly.", ass.DefinedTypes.Count(), methodCount, assName.Name);
}

위와 같이 code를 작성한 뒤 실행하면 현재 동작중인 OS상에서 Application이 실행될 때 가능한 type과 method의 수를 아래와 같이 표시하게 됩니다. OS에 따라 표시되는 값은 약간씩 다를 수 있습니다.

0 types and 0 methods in System.Runtime assembly.
119 types and 1,491 methods in System.Linq assembly.
44 types and 656 methods in System.Console assembly.

위 결과를 보면 System.Runtime은 type과 method가 0인 것을 알 수 있습니다. System.Runtime은 runtime에서 동적으로 type과 method를 결정하는데, 많은 BCL(Base Class Library) assembly들이 reference assembly로만 존재하고 있으며 System.Runtime에서는 metadata만 가지고 있고 실제 구현 type은 다른 곳에 들어 있기 때문입니다.

C#에서 가능한 Method와 type이 얼마나 있는지는 가늠할 수 없습니다. Method는 type이 가질 수 있는 member 중 하나에 불과하며 지금도 수많은 개발자가 나름대로의 새로운 type과 member를 정의하고 있기 때문입니다.

3. 변수

어떠한 application이라도 원하는 결과를 얻기 위해서는 처리할 data를 필요로 합니다. 계산기 application을 만든다고 가정했을 때 산술계산에 필요한 수를 전달해야 하는데 이것이 바로 data인 것입니다.

Data는 대게 사용자가 입력한 것일 수 있고, database나 file과 같은 매체를 통해 전달될 수도 있습니다. 그리고 이렇게 전달된 data를 application에서 다루고자 할 때 임시적으로 변수에 담는 처리를 통해 computer의 memory에 저장하게 됩니다. 저장된 data는 나름대로의 처리과정을 거치게 되고 그 결과 data를 생성하게 되는데 일반적으로 Application이 종료되면 관련 memory전체가 소멸되기 때문에 결과 data는 다시 database나 file 등에 저장하거나 또는 사용자에게 직접 표시하여 처리 결과를 확인할 수 있도록 합니다.

변수를 사용할 때 가장 기본적인 질문은 '다루고자 하는 data에서 얼마나 많은 memory공간을 필요로 하는가?'라는 것입니다. 그리고 우리는 변수의 적절한 type을 지정함으로써 이러한 질문에 응답할 수 있습니다. 여기서 흔히 하는 오해중 하나가 '더 적은 memory type이 더 빨리 수행될 것이다.'라고 추측하는 것입니다. 그러나 항상 그런 것만은 아닙니다. int나 double와 같은 일반적인 type은 각자 차지하는 memory공간이 다르지만 그렇다고 더 빨리 수행되지는 않습니다. 64bit OS에서 16bit 값과 64bit 값은 동일한 조건에 놓여있기 때문에 처리 속도에는 차이가 없습니다. 그리고 일반적인 변수는 서로 근접한 memory공간에 할당될 수 있지만 일부 큰 data의 경우 heap구조를 통해 멀리 떨어진 memory영역에 저장될 수 있습니다. 이러한 memory저장방식은 stack과 heap으로 구분될 수 있는데 이에 대해서는 잠시 후 더 자세히 알아볼 것입니다.

1) 변수의 Naming규칙과 값할당

변수를 선언할 때는 해당 변수에 대한 이름을 지정해야 합니다. 변수뿐만 아니라 type, method 등 거의 모든 부분에서 개발자의 작명감각이 필요한데, 이때 이름은 직관적이어야 하며 특정한 의미를 연상할 수 있어야 합니다. 또한 다음과 같은 규칙이 존재하므로 가급적이면 해당 규칙을 준수하여 이름을 붙여주는 것이 좋습니다.

규칙방식	설명
Camel case	소문자로 시작해 단어 사이의 구분을 대문자로 지정합니다. userName, age, addressOfBase와 같은 형태가 될 수 있으며 지역변수와 private field에 사용합니다.
Pascal case	Camel case와 달리 대문자로 시작합니다. UserName, Age, AddressOfBase와 같은 형태가 될 수 있으며 type과 type의 member(method와 같은), 그리고 private이 아닌 모든 field에 사용합니다.

어떤 경우에는 _age와 같이 private field에 _(underscore) 문자를 접두사로 붙여주는 경우도 있는데 private은 외부에 노출되지 않기 때문에 '_'사용여부에 관해서는 별다른 규칙이 존재하지 않습니다.

Team단위나 조직별로 별도의 naming규칙을 적용할 수도 있습니다. 중요한 건 어떤 규칙이든 일관성 있게 적용해야 한다는 것이며 이를 통해 code를 이해하기에 쉬운 접근성을 제공해 줄 수 있습니다.

아래 예제에서는 지역변수를 선언하고 해당 변수에 값을 할당하고 있습니다. 값의 할당은 '='문자를 사용하며 참고로 변수자체의 이름을 표현할 때는 nameof 연산자를 사용할 수 있습니다.

int userAge = 50;
Console.WriteLine($"변수 nameof(userAge)의 값은 {userAge}입니다.");

nameof 연산자는 C# 6부터 도입된 것이며 C# 12부터는 정적 context의 instance data에도 사용할 수 있습니다. instance와 static에 관해서는 추후에 자세히 알아볼 것입니다. 또한 'nameof(List<>)'와 같이 bound 되지 않은 generic type에도 사용할 수 있게 되었습니다.

2) Literal

변수에 값을 할당할 때는 대게 고정된 값을 의미하는 literal값을 할당합니다. 이때 data type에 따라 할당 가능한 literal값의 표기방법이 달라질 수 있습니다. 정수라면 10, 20과 같은 값을 할당할 수 있지만 문자열이라면 "abc"나 "가나다라"와 같이 값을 할당해야 합니다. C#언어의 literal에 관한 더 자세한 사항은 아래 link를 참고해 주시기 바랍니다.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#645-literals

Lexical structure - C# language specification

This chapter explains the lexical grammar, and the syntactic grammar of the C# language.

learn.microsoft.com

3) 문자/문자열

하나의 문자를 저장하는 경우라면 char type을 사용할 수 있습니다.

대게 하나의 문자를 하나의 char type으로 나타낼 수 있다고 생각하기 쉬운데, 꼭 그런 것만은 아닙니다. 영문자나 숫자의 경우 별 문제가 없고 다른 곳에서의 char에 대한 설명도 편의상 '1개의 문자는 1개의 char를 사용한다.'라고 하지만, 이집트 상형문자의 경우 해당 문자를 표현하기 위해 2개의 char type(이런 것을 surrogate pair라고 합니다.)을 필요로 합니다. 이러한 방식은 일부 아시아국가에서의 문자에서도 마찬가지니 주의하시기 바랍니다.

단일 한 개의 문자를 literal표 표현하려면 홑따옴표를 사용해야 합니다.

char c = 'a';

반면 문자가 하나이상 존재하는 '문자열'은 큰따옴표를 사용해 표현하며 string type을 사용해야 합니다.

string userName = "kim sang hyun";
string doubleA = new ('a', 2); //2개의 a문자 표현
string emoji = char.ConvertFromUtf32(0x1F600);

Windows Termial에서는 emoji를 표현할 수 있는 기능이 있는데 이 기능을 통해 emoji를 표현하려면 UTF-8로 encoding을 수행한 뒤 char.ConvertFromUtf32 method를 사용해야 합니다. 이러한 방식은 Emoji뿐만 아니라 한글과 같은 일부 아시아국가의 고유문자를 나타내기 위한 방법이기도 합니다.

Console.OutputEncoding = System.Text.Encoding.UTF8;
string emoji = char.ConvertFromUtf32(0x1F603); //Grinning Face with Big Eyes
Console.WriteLine(emoji);

(1) ESC(Escape) 문자 다루기

C# 13부터 ESC문자(Unicode U+001B)는 '\e'확장문자열로 나타낼 수 있습니다.

char esc = '\e';

C# 13 이전이라면 ESC문자를 \u001b로 표현해야 합니다. 어떤 경우에는 \x1b로 나타내는 경우가 있었으나 1b 뒤에 오는 16진수 문자가 확장문자열(Escape sequence)로 잘못 해석될 수 있기 때문에 사용을 권장하지 않습니다.

(2) Verbatim string

Escape문자는 programming에서 문자열을 처리할 때 확장문자열(Escape sequence)을 도입하기 위해 사용되는 특수한 문자입니다. 확장문자열은 문자열에 직접적으로 삽입이 불가능하거나 그렇게 하기 어려운 문자를 표현할 수 있게 하는 것으로 backslash(\) 문자로 시작하여 처리하고자 하는 문자열값을 지정합니다.

예를 들어 문자열에서 tab문자를 표현하고자 하는 경우 아래와 같이 문자열을 구성하여 변수에 저장할 수 있습니다.

string tabInName = "Kim\tLee";

그런데 만약 아래와 같이 file의 경로를 지정하는 경우 특정 folder의 이름이 공교롭게도 t로 시작하게 된다면 어떻게 될까?

string path = "C:\source\test\mycs.cs";

위와 같은 상태에서 compile을 시도하면 compiler는 '\test'에서 '\t'를 tab문자료 변환하기에 정상적인 경로값이 되지 않을 것입니다. 뿐만 아니라 \s나 \m 역시 유효한 확장문자열이 아닌 것으로 오류를 표현하기 때문에 compile조차 되지 않습니다. 다시 말해 '\'뒤에 모든 문자열은 확장문자열로 우선처리하도록 하고 있으므로 이 가운에 유효하지 않은 확장문자열이 존재한다면 compiler는 오류를 발생시키는 것입니다.

C#에서 사용가능한 확장문자열은 아래 link에서 확인하실 수 있습니다.
https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/strings/#string-escape-sequences

Strings - C#

Learn about strings in C# programming. See information on declaring and initializing strings, the immutability of string objects, and string escape sequences.

learn.microsoft.com

다만 아래와 같이 문자열 앞에 '@'문자를 접미사로 붙이면 문자열 안에 모든 '\'문자는 확장문자열의 시작이 아닌 문자 그대로 해석하게 되므로 file이나 folder의 경로를 나타내고자 할 때 유용하게 사용할 수 있습니다.

string path = @"C:\source\test\mycs.cs";

(3) 원시 문자열 (Raw string literal)

C# 11부터 사용되어 온 원시문자열 표현방법은 text를 escape 하지 않고도 문자열 그대로 입력할 수 있어서 문자열 안에 XML이나 HTML, JSON과 같은 contnet를 편리하게 포함시킬 수 있습니다.

원시문자열은 아래와 같이 세 개의 큰따옴표를 문자열의 처음과 끝에 붙여주는 방법으로 사용됩니다.

string html = """
    <div>
        <span style="color:red">Hello!</span>
    </div>
    """;

Console.WriteLine(html);

원시문자열표현방법에서 기본 세 개의 큰따옴표가 사용되는 이유는 문자열자체적으로 큰따옴표를 포함하는 경우 때문입니다. 만약 문자열내부에서 3개의 큰따옴표가 포함되어야 한다면 해당 문자열 앞뒤로 4개의 큰따옴표로 감싸야 하며 문자열내부에 4개의 쌍따옴표가 포함된다면 5개의 쌍따옴표로 감싸줘야 합니다. 원시문자열은 이와 같은 방법으로 내부에 포함된 큰따옴표수보다 더 많은 큰따옴표를 통해 문자열을 감싸줘야 합니다.

또한 위 예제를 보면 문자열 끝에 세 개의 쌍따옴표의 들여쓰기가 내부 content와 동일한 수준을 유지하고 있다는 것을 알 수 있습니다. 이와 같은 방법을 통해 compiler는 모든 문자열앞에 들여쓰기 수준을 마지막 세개의 큰따옴표와 동일하게 유지하도록 처리하게 할 수 있습니다. 따라서 위 예제를 실행하면 내부 html의 앞에 들여 쓰기 수준이 모두 제거된 상태로 다음과 같이 문자열을 값을 표현하게 됩니다.

따라서 아래와 같이 문자열 끝에 큰따옴표를 왼쪽에 맞춰 들여 쓰기를 없애면

string html = """
    <div>
        <span style="color:red">Hello!</span>
    </div>
""";

Console.WriteLine(html);

그만큼 내부 문자열에 들여 쓰기 수준을 그대로 적용하여 표현할 것입니다.

① 원시 보간 문자열(Raw interpolated string literals)

원시 문자열 안에서 보간 문자열을 사용하기 위한 방법은 일반 문자열의 경우와 크게 다르지 않습니다. 다만 문자열 시작지점에 보간 문자열의 표현식으로 나타낼 중괄호({})의 수만큼 '$'문자를 지정하고 문자열 안에서 동일한 수의 중괄호를 사용해야 합니다.

예를 들어 문자열안에서 하나의 중괄호를 있는 그대로의 일반적인 문자열로 취급해야 한다면 2개의 중괄호를 사용해 보간 문자열의 표현식으로 사용해야 합니다. 따라서 아래와 같이 $문자를 2개 사용하고 문자열 안에서도 보간 문자열을 위해 중괄호를 2개 사용합니다.

string say = "hello!";
string html = $$"""
    <div>
        <span style="color:red">{{say}}</span>
    </div>
""";

Console.WriteLine(html);

즉, $문자는 compiler에게 문자열안에서 몇 개의 중괄호가 보간 문자열의 표현식으로 인식되어야 하는가를 알려주는 역할을 하는 것입니다. 이를 바꿔 말하면 중괄호가 사용되지 않는 일반 문자열에서는 $문자를 하나만 붙이고 중괄호 역시 하나만 사용하여 보간 문자열을 나타내도 아무런 문제가 되지 않는다는 것을 의미합니다. 하지만 만약 원시 문자열이 중괄호가 빈번하고 중대한 의미로 사용되는 JSON을 나타내야 하는 경우라면 이와 같은 방법이 매우 중요하고 편리하게 작용할 수 있으므로 꼭 기억하시기 바랍니다.

4) 숫자

C#에서 숫자라 함은 간단히 더하기와 같은 산술계산에 사용되는 값이라 말할 수 있습니다. 그런 의미에서 전화번호는 숫자가 될 수 없습니다. 예를 들어 변수를 사용할 때 숫자로 된 data가 존재하는 경우 이걸 숫자 Type에 넣을지 문자열 Type에 넣을지 고민된다면 그 값이 산술연산에 사용될 수 있는 값인지, 숫자로 구성된 data에서 서식화를 위해 괄호나 hypen과 같은 특수 문자가 사용되었는지를 명확하게 판단하여 결정해야 합니다.

여기서 숫자는 31, 32와 같이 셈이 가능한 범자연수(Whole number)가 될 수 있고 또는 -31처럼 음수(Integer)가 될 수 있으며 1.3처럼 실수(단정도 또는 배정도 부동 소수점)가 될 수도 있습니다.

int num = 31;
uint unum = 31;
float fnum = 1.3f;
double dnum = 1.3;

위 예제에서 uint는 unsigned integer라 하여 음수를 사용하지 않는 대신 int보다 더 넓은 범위의 양수를 표현할 수 있습니다. float은 단정도 부동 소수점으로 F 또는 f를 값의 접미사로 붙여 표현합니다. double은 배정도 부동 소수점으로서 실수에서 기본적으로 표현되는 type이므로 실수에 별도의 접미사를 붙이지 않으면 double로 인식합니다.

Whole number는 범자연수라 하여 음수를 제외한 0부터의 숫자를 의미하며 integer는 자연수로 음수를 포함한 숫자를 의미합니다.

(1) 범자연수 (Whole numbers)

Computer는 모든 정보를 0과 1만으로 구성된 bit값으로 저장하며 0과 1, 단 2개의 숫자만 사용하므로 이를 '2진수(2진법)'라고 표현합니다.

아래 표는 10의 값을 computer가 저장할 때 만들어지는 bit를 표현하고 있습니다.

위 표에서 8과 2에 1이 표시되어 있음에 주목하시기 바랍니다. 8+2면 10의 값이 성립되는데 결론적으로 2진수 총 8bit로 구성된 00001010은 10진수 10의 값과 같다고 할 수 있습니다.

① 숫자 구분자를 사용한 가독성 향상

C# 7부터는 underscore(_) 문자를 사용하여 원하는 만큼의 숫자를 분리해 줄 수 있으며 이러한 방법은 2진수나 16진수와 같은 여러 유형의 값을 표현할 때도 적용할 수 있습니다.

숫자를 분리하는 데 사용되는 '_'문자는 숫자를 표현할 때 해당 숫자의 어디서든 삽입이 가능한데 예를 들어 1백만의 숫자를 표현하는 경우

1000000

위와 같이 표현하는 것보다 천 단위로 분리하여

1_000_000

작성하면 가독성면에서 훨씬 도움이 될 것입니다.

② 2진수와 16진수 표기법

C#에서 2진수 값을 직접적으로 표현하려면 해당 숫자의 앞에 0b를 붙여줄 수 있습니다. 0~9, A~F까지 사용하는 16진수의 경우에는 0x를 사용합니다.

int decimal = 1_000_000; //10진수
int binary = 0b_1111_0100_0010_0100_0000; //2진수
int hexadecimal = 0x_000F_4240; //16진수

Console.WriteLine($"{decimalNotation:N0}");
Console.WriteLine($"{binaryNotation:N0}");
Console.WriteLine($"{hexadecimalNotation:N0}");

Console.WriteLine($"{decimalNotation:X}");
Console.WriteLine($"{binaryNotation:X}");
Console.WriteLine($"{hexadecimalNotation:X}");

예제에서 'N0'은 10진수를, X는 16진수를 나타내므로 실행결과는 다음과 같을 것입니다.\

(2) 실수

C#에서 실수에 사용되는 type 중 float와 double은 각각 단정도 부동 소수점과 배정도 부동 소수점을 사용해 표현합니다.

대부분의 Programming언어는 부동 소수점을 다루기 위해 IEEE(Institute of Electrical and Electronics Engineers) 표준을 구현하고 있는데 여기서 IEEE 754가 1985년에 만들어진 부동 소수점을 위한 기술적 표준에 해당합니다.

아래 표는 computer에서 12.75라는 실수값을 표현하기 위한 2진수를 나타내고 있는데, 1이 표시된 부분만 모두 계산하면 8 + 4 + 1/2 + 1/4가 되므로 결과는 12.75가 됩니다.

12.75 값은 이진수 00001100.1100으로 정확하게 표현할 수 있지만 다른 수는 거의 대부분 정확한 표현이 불가능하며 근사치로만 나타냅니다.

① 예제를 통해 number type의 size 알아보기

C#에서는 sizeof라는 연산자를 통해 type에서 사용하는 memory의 byte값을 확인할 수 있습니다. 또한 대부분의 number type에서는 자체적으로 해당 type의 변수가 가질 수 있는 최솟값과 최댓값을 표현하는 MinValue와 MaxValue를 속성을 가지고 있는데 이들을 조합하여 다음과 같이 type의 수용범위를 알 수 있는 간단한 예제를 만들어 볼 수 있습니다.

Console.WriteLine($"int : {sizeof(int)} bytes, range : {int.MinValue:N0} to {int.MaxValue:N0}.");
Console.WriteLine();
Console.WriteLine($"double : {sizeof(double)} bytes, range {double.MinValue:N0} to {double.MaxValue:N0}.");
Console.WriteLine();
Console.WriteLine($"decimal : {sizeof(decimal)} bytes, range {decimal.MinValue:N0} to {decimal.MaxValue:N0}.");

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

결과를 보면 int는 4byte에 음수부터 양수까지 2십억 정도의 값을 가질 수 있고 double은 8byte에 int보다 더 많은 값을 가질 수 있습니다. Decimal은 16byte를 사용하므로 double보다 더 많은 memory를 사용하지만 표현가능한 값의 범위는 double보다 더 작음을 알 수 있습니다.

그렇다면 왜 decimal은 double보다 memory는 더 많이 사용하면서도 값의 범위는 오히려 더 작은 걸까?

이 질문에 대한 답을 알아보기 위해 우선 아래와 같은 에제를 작성해 보았습니다. 예제는 2개의 double변수를 선언하고 이들에 +연산자를 적용한 뒤 그 결괏값을 비교하고 있습니다.

double d1 = 0.1;
double d2 = 0.2;

double r = d1 + d2;

if (r == 0.3)
    Console.WriteLine("result : 0.3");
else
    Console.WriteLine($"result : {r}");

위 에제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제의 결과에서 보듯 double은 정확성을 기대할 수 없습니다. 0.1과 0.2, 0.3과 같은 값은 부동 소수점에서는 문자 그대로의 정확한 표현이 불가능하기 때문입니다.

그러나 예제와 약간 다르게 0.1 + 0.3의 식을 대신 사용해 보면 이번에는 0.4라는 정확한 값이 산출됨을 알 수 있습니다. double type에서 실제로는 수학적으로 같지 않음에도 불구하고 현재 표현식에서 정확히 동일한 값으로 간주되는 일부 부정확한 값이 존재할 수 있습니다. 결론은 너무나 모호하지만 일부는 정확한 비교가 가능하나 일부는 그렇지 않다는 것입니다.

대신 float type으로 실수를 다루는 경우에는 위 예제와 같은 비교에서 더 정확한 결과를 낼 수 있습니다. 그 이유는 double type보다 정확도가 더 떨어지기 때문입니다.

float f1 = 0.1f;
float f2 = 0.2f;

float r = f1 + f2;

if (r == 0.3f)
    Console.WriteLine("result : 0.3");
else
    Console.WriteLine($"result : {r}");

따라서 값자체의 비교보다는 표현의 정밀도가 더 중요하다면 double을 사용하고 값의 비교가 더 중요한 경우에는 float을 사용해야 합니다. 중요한 건 double에서 절대로 '=='비교연산자를 통해 값을 비교해서는 안된다는 것입니다.

Double을 사용한 위 에제에서는 computer가 실수값을 어떻게 저장하는지를 보면 왜 예상한 것과 다른 결과를 내는지 알 수 있습니다. 2진수에서 0.1이라는 값을 표현하기 위해 double에서는 아래표에서와 같이 1/16, 1/32, 1/256, 1/512... 등등에 계속해서 1이라는 값을 저장해야 합니다. 따라서 결국 0.1 값은 2진법으로 0.00011001100110011... 이 되는 것입니다.

아래 예제는 double예제에서 data type을 decimal로 변경한 것입니다.

decimal d1 = 0.1M;
decimal d2 = 0.2M;

decimal r = d1 + d2;

if (r == 0.3M)
    Console.WriteLine("result : 0.3");
else
    Console.WriteLine($"result : {r}");

위 예제를 실행해 보면 이전과 달리 r변수의 값이 0.3을 가지게 된다는 것을 알 수 있습니다.

Decimal의 실수저장방식은 의외로 단순한데, 모든 수를 정수형태로 저장한 뒤 소수 부분의 숫자만 이동시키는 방식을 따르고 있습니다. 예를 들어 0.1의 값은 1로 저장되며 소수점 1자리만큼 이동시켜 0.1을 표현합니다. 12.75도 마찬가지인데 12.75를 1275로 저장한 다음 소수점 자리만큼 뒤의 75를 이동시켜 12.75로 표현합니다. 이러한 저장 방식은 실수 전체를 큰 범위의 정수형태로 저장하게 되므로 많은 정수 부분의 공간을 필요로 하게 됩니다. 따라서 double보다 더 많은 memory공간을 필요로 하게 되는 것입니다. 하지만 이러한 방식은 double에서 거의 무한적으로 반복되는 정밀도를 따라가기에는 한계가 있기 때문에 당연히 소수의 정밀도 면에서는 double을 따라갈 수 없습니다.

일반적인 자연수는 int를 사용합니다. 다른 값과의 정확한 비교가 필요 없으면 double을 사용합니다. double은 정확힌 비교가 아닌 비교대상보다 더 큰가, 작은 가를 판단하기에 좋지만 값의 정확한 비교에는 적절하지 않습니다.

② 기타 실수 관련 상수와 method

float과 double은 특별한 경우에 사용가능한 몇 가지 유용한 상수를 갖고 있습니다. 대표적으로 NaN은 not a number로서 0에서 0으로 나눈 결과를 표현하는 것이며 Epsilon은 float과 double에서 저장가능한 가장 작은 양수값을 나타냅니다. PositiveInfinity와 NegativeInfinity는 무한대의 양의실수와 음수값을 표현하며 IsInfinity와 IsNaN과 같이 이들 값을 확인할 수 있는 method도 존재합니다.

아래 예제는 이와 같은 상수를 활용한 것으로 해당 상수값이 어떻게 표현되는지 알 수 있습니다.

Console.WriteLine($"double.Epsilon: {double.Epsilon}");
Console.WriteLine($"double.Epsilon(decimal places-324): {double.Epsilon:N324}");
Console.WriteLine($"double.Epsilon(decimal places-330): {double.Epsilon:N330}");
Console.WriteLine();
Console.WriteLine($"double.NaN: {double.NaN}");
Console.WriteLine();
Console.WriteLine($"double.PositiveInfinity: {double.PositiveInfinity}");
Console.WriteLine($"double.PositiveInfinity: {double.NegativeInfinity}");

PositiveInfinity와 NegativeInfinity는 옆으로 누 운모양의 8을 표시하는데 각각 양의 실수와 음의 실수를 0으로 나눈 표현식에서 생성될 수 있습니다. Epsilon은 5E-324보다 약간 작은 값으로 아래 link에서의 표시법으로 표현됩니다. https://en.wikipedia.org/wiki/Scientific_notation

3) 신규 number type과 unsafe code

System.Half type은 .NET 5에서 도입된 것으로 float이나 double처럼 실수를 저장하지만 32bit의 float이나 64bit의 double과 다르게 2byte의 memory만을 사용함으로써 그만큼 memory를 절약하고 cache의 효율성을 증대시킬 수 있습니다. 다만 값의 범위는 더 작아지므로 대규모 data를 처리하는 데는 주의해야 합니다. System.Int128과 System.UInt128은 .NET 7에서 도입되었는데 int와 uint같이 음수와 양수모두를 저장하거나 0을 포함한 양수만을 저장합니다. 차이점은 더 많은 memory를 사용하기에 더 큰 정수 범위를 표현할 수 있습니다.

아래 예제는 위의 type의 표현범위를 알아보기 위한 것으로 내부에서 sizeof 연산자를 사용하였습니다.

unsafe
{
    Console.WriteLine($"Half : {sizeof(Half)} bytes, range {Half.MinValue:N0} ~ {Half.MaxValue:N0}");
    Console.WriteLine($"Int128 : {sizeof(Int128)} bytes, range {Int128.MinValue:N0} ~ {Int128.MaxValue:N0}.");
}

sizeof 연산자를 위와 같이 사용함으로 인해 code를 unsafe를 통해 구현해하며 이를 build 하려면 Project의 설정에 아래와 같이 AllowUnsafeBlocks를 추가해야 합니다.

<PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
</PropertyGroup>

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

sizeof 연산자는 int나 byte와 같이 일반적으로 사용되는 type을 제외하곤 unsafe code block을 사용해야 합니다. sizeof 연산자에 관한 더 자세한 사항은 아래 link를 참고하시기 바랍니다.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/sizeof

sizeof operator - determine the storage needs for a type - C# reference

Learn about the C# `sizeof` operator that returns the memory amount occupied by a variable of a given type.

learn.microsoft.com

다만 unsafe code block을 사용하면 그만큼 안정성을 검증할 수 없습니다. 이에 관한 자세한 사항은 아래 link를 참고하시기 바랍니다.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/unsafe-code

Unsafe code, pointers to data, and function pointers - C# reference

Learn about unsafe code, pointers, and function pointers. C# requires you to declare an unsafe context to use these features to directly manipulate memory or function pointers (unmanaged delegates).

learn.microsoft.com

4) bool

bool은 true와 false값 중 하나만을 가질 수 있는 type으로서 아래와 같이 사용됩니다.

bool b1 = true;
bool b2 = false;

bool type자체는 조건을 판단하는데 가장 많이 사용되는 type으로서 분기문이나 loop문에 응용됩니다. 분기문 및 loop문에 관한 자세한 사항은 추후에 자세히 알아볼 것입니다.

5) object

C#에서 object type은 모든 type을 저장할 수 있는 아주 특별한 type입니다. 하지만 자칫 이해하기 어려운 code를 만들 수 있고 특히 application의 성능을 떨어뜨리는 주요 원인이 될 수 있으므로 가급적 사용을 피해야 합니다.

아래 예제에서는 object에 값을 저장하거나 가져올 때 어떤 형태로 사용될 수 있는지를 알 수 있습니다.

object o1 = 100;
object o2 = "abcdefg";

Console.WriteLine($"{o1} : {o2}");

int i = (int)o1;
string s = (string)o2;

Console.WriteLine($"{i} : {s}");

예제를 실행하면 아래와 같은 결과를 표시할 것입니다.

예제와 같이 object에서 data를 가져올 때는 본래 해당 data가 어떤 type인지 알 수 없기 때문에 적절한 type으로의 형변환이 필요합니다. 따라서 아래와 같이 code를 작성하면 compile error가 발생할 수 있습니다.

object s1 = "abcdefg";
string s2 = s1.Length; //error : s1을 문자열로 취급하려면 형변환이 필요하다.

형변환 관한 자세한 사항은 추후에 살펴볼 것입니다.

C#의 초기 version부터 사용되어 온 object는 형변환이 필수적으로 따라와야 하기 때문에 여기에서 발생하는 성능상 부하가 경우에 따라서는 아주 크게 작용할 수 있습니다. C#에서는 이러한 문제를 해결하기 위해 generic을 도입하게 되었는데 generic은 object와는 다르게 충분한 유연성을 제공하면서도 성능저하에 관한 문제를 피할 수 있습니다. Generic에 관한 자세한 사항은 추후에 자세히 알아볼 것입니다.

6) dynamic

C# 4에서 도입된 dynamic은 object와 같이 모든 type의 data를 담을 수 있는 type이며 또한 비슷하게 성능저하를 일으키는 원인이 될 수 있습니다. object와 비슷하지만 한 가지 다른 차이점이라면 저장된 값의 type을 명시적으로 형변환하지 않고도 그대로 사용할 수 있다는 것입니다.

dynamic s = "abcdefg";

int sLen = s.Length;

Console.WriteLine(sLen);

위 예제는 어떠한 compile 오류도 발생시키지 않고 정상적으로 7이라는 결괏값을 표시할 것입니다. 할당된 값자체가 문자열값이며 해당 type은 Length라는 속성을 가지고 있기 때문에 아무런 문제가 되지 않습니다. 여기서 중요한 건 dynamic은 항상 마지막에 할당된 값의 type을 유지한다는 것입니다. 따라서

dynamic s = "abcdefg";
s = 100;

int sLen = s.Length;

Console.WriteLine(sLen);

위와 같은 예제는 compile 오류를 발생시킵니다. 마지막으로 할당된 값은 100이며 int type에 해당하므로 Length라는 속성을 가지지 않기 때문입니다. dynamic의 또 한 가지 특징은 code를 작성할 때 IntelliSense의 도움을 받을 수 없다는 것도 있습니다. 왜냐하면 dynamic은 code를 작성하는 중에는 type을 확인하지 않기 때문이며 type의 member 역시 runtime시에 CLR(Common Language Runtime)이 확인하는 과정을 거치게 됩니다. 따라서 만약 runtime에서 해당 member가 확인되지 않으면 예외를 발생시키게 됩니다.

예외에 관해서는 추후에 자세히 알아볼 것입니다.

Dynamic type은 주로 비 .NET system과의 상호작용을 위해 사용되는 경우가 많습니다. 대표적으로 F#이나 Python, JavaScript를 예로 들 수 있으며 Excel이나 Word와 같이 COM(Component Object Model)과의 상호작용을 위해서도 사용됩니다.

(1) Dynamic과 ExpandoObject

ExpandoObject는 System.Dynamic namespace안에 존재하는 것으로 runtime에서 임의의 속성을 추가하거나 삭제할 수 있는 dynamic개체이며 추가되는 속성을 위해 내부적으로 dictonary를 사용하여 key와 값을 저장하고 관리합니다. 뿐만 아니라 단순 속성을 벗어나 Action과 같은 delegate를 할당하여 method의 추가를 구현할 수도 있습니다.

ExpandoObject는 주로 고정된 형태의 class가 아닌 동적인 동작을 필요로 하는 경우에 유용하게 사용할 수 있습니다. 다만 성능이 중요시되거나 비교적 안전한 code가 필요한 환경이라면 ExpandoObject의 사용을 피하는 것이 좋습니다.

아래는 ExpandoObject를 어떠한 형태로 사용할 수 있는지를 확인해 볼 수 있는 간단한 예제입니다.

using System.Dynamic;

dynamic car = new ExpandoObject();

car.MaxSpeed = 200;
car.MaxPassengers = 4;
car.CarType = "Sedan";
Console.WriteLine($"{car.CarType} Maximun Speed : {car.MaxSpeed}");

Console.WriteLine("--------------------------------------------");

var dic = (IDictionary<string, object>)car;
foreach(var item in dic)
{
    Console.WriteLine($"{item.Key} : {item.Value}");
}

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제에서 사용된 data type cast와 dictonary에 관해서는 추후에 자세히 알아볼 것입니다.

7) 변수의 선언

지역변수라 함은 method안에서 선언되는 것들을 의미하며 오로지 method가 실행되는 동안에만 유효합니다. 그런데 Method의 실행이 종료되는 순간 memory에 할당된 지역변수는 값 type인 경우 소멸하지만 참조 type인 경우 garbage collection을 대기하게 됩니다. 변수의 값 type과 참조 type의 차이에 대해서는 이제 곧 알아볼 것입니다.

(1) 지역변수의 type 지정하기

지금까지 예제를 통해 꾸준히 봐온 바와 같이 변수는 type과 변수명의 방식으로 아래와 같이 선언됩니다.

int age = 20;
double weight = 60.1;
decimal price = 5.99M;
string fruit = "apple";
char alpabet = 'A';
bool isUse = false;

만약 변수를 선언만 하고 해당 변수를 사용하는 구문을 따로 작성하지 않는다면 사용하고 있는 editor와 색상 설정에 따라 물결모양 밑줄과 함께 '변수에 값이 할당되었지만 사용되지 않는다.'는 경고를 표시할 수 있습니다.

(2) 변수의 type 추론

C# 3 이후부터는 변수를 선언할 때 var keyword를 사용할 수 있습니다. Compiler가 var가 사용된 변수를 만나면 할당된 값을 통해 type을 추론하게 되는데 이러한 동작은 compile 할 때 실행되므로 runtime에 미치는 성능적인 영향은 없습니다.

type추론에도 일정한 규칙이 존재하는데 var type변수에 숫자값을 할당할 때는 아래와 같이 값뒤에 붙여주는 접미사를 통해 적절한 type을 추론하게 됩니다.

접미사	추론되는 type
L	long
UL	ulong
M	decimal
D	double
F	float

소수점이 없는 정수값을 할당하는 경우에는 int로 추론되며 어떠한 접미사도 없으면서 실수면 double로 추론됩니다. 숫자가 아닌 문자열의 경우 큰따옴표가 사용되면 string으로, 홑따옴표가 사용되면 char type으로 추론되며 true나 false가 사용되면 bool로 추론됩니다.

실제 상기 변수선언의 예제를 var를 사용해 변경하면 아래와 같이 할 수 있으며 각 규칙에 따라 type이 추론됩니다.

var age = 20;
var weight = 60.1;
var price = 5.99M;
var fruit = "apple";
var alpabet = 'A';
var isUse = false;

사용하는 code editor에 따라 var keyword에 mouse pointer를 올려두면 추론된 type을 표시하기도 합니다.

type추론은 위와 같은 일반적인 변수에만 적용되는 것은 아닙니다. 복합 type에도 적용될 수 있는데, 예를 들어 C# 3 이전에는

XmlDocument xml = new XmlDocument();

위와 같이 해야 했지만 var type을 통해 아래와 같이 XmlDocument type에 대한 변수를 선언해 줄 수 있습니다.

var xml = new XmlDocument();

var keyword는 편리하기는 하지만 type을 즉각적으로 파악할 수 없다는 점 때문에 일부 개발자은 var사용을 선호하지 않는 경우도 있습니다. var를 무조건 사용하거나 또는 사용하지 않기로 마음먹기보다는 type이 명확한 경우에는 var를 사용하고 그렇지 않은 경우 메는 해당 type을 명시적으로 지정하여 변수를 선언하는 것도 괜찮은 방법이 될 수 있습니다.

간혹 var를 dynamic과 혼동하는 경우가 있는데 dynamic은 dynamic자체를 compiler가 변경하는 경우가 없으며 runtime에서 type이 확인된다는 점에서 var와는 동작방식이 다릅니다.

Visual Studio에서는 var를 실제 type으로 자동적으로 바꿔주는 refactoring기능을 사용할 수 있습니다. 자세한 사항은 아래 link를 통해 확인할 수 있습니다.
https://learn.microsoft.com/en-us/visualstudio/ide/reference/convert-var-to-explicit-type?view=visualstudio

Refactor code to replace var with an explicit type - Visual Studio (Windows)

Learn how to use Quick Actions to replace var in a local variable expression with an explicit type.

learn.microsoft.com

(3) new keyword

지금까지 C# code에 대한 몇 가지 예제에서는 명확한 설명 없이 new keyword를 계속 사용해 왔습니다. new keyword는 기본적으로 memory에 대한 초기화 및 할당에 사용되는 것으로 변수의 참조 type에서 사용됩니다.

값 type에서는 memory할당을 위한 new keyword가 사용되지 않지만 literal을 사용해 값을 초기화하기 위한 방법이 마땅치 않은 경우 사용될 수도 있습니다. 그러나 대부분 new keyword를 굳이 사용해야 하는 경우는 없으며 사용한다 하더라도 참조 type에서의 new와 동일한 의미를 가지지는 않습니다.

값 type은 변수를 선언할 때 값을 저장하기 위한 stack memory만을 할당합니다. 이러한 방식은 int나 char처럼 변수가 가져야 할 정해진 memory의 크기가 이미 지정되어 있으므로 가능한 방식입니다. 그러나 참조 type은 해당 변수를 위한 memory공간을 어디서부터 어디까지 할당해야 할지 미리 예견할 수 없으므로 heap이라는 특별한 memory공간을 사용해야 하며 stack memory는 실제 data가 저장된 heap의 memory주소를 기억하기 위한 용도로만 사용합니다.

참조 type의 경우에도 변수를 선언하는 경우 new를 사용하지 않으면

Car car;

heap에 존재하는 Car개체의 memory주소를 저장하기 위한 stack memory만을 확보(memory주소만을 가질 것이므로 32bit의 경우 4byte를 64bit system의 경우 8byte를 확보)하게 되며 아직 개체를 위한 heap memory까지 할당된 상태에 있지는 않습니다. 따라서 아직 값이 지정되지 않았으므로 이때 변수 car는 null상태가 됩니다. int와 같은 값 type에서 값이 할당되지 않은 경우 기본값 0을 가지는 것과는 다른 것입니다.

Car car = new Car();

new keyword를 사용하면 이 순간 car개체를 저장하기 위한 heap memory를 할당합니다. 이때부터 car는 더 이상 null이 아닙니다.

① 대상형식화된 new(target-typed new)

C# 9에서는 개체를 초기화하기 위한 새로운 구문으로 target-typed new를 도입하였습니다. 개체를 초기화할 때 변수의 type을 지정하고 나면 new를 사용할 때 이를 반복할 필요 없이 new keyword만을 사용하여 아래와 같이 개체를 초기화하는 방식입니다.

XmlDocument xml = new();

참조 type이 특정 type의 field나 속성인 경우 이에 값을 할당하는 경우에도 type은 추론될 수 있습니다.

Car car = new();
car.ShipDate = new(2025, 12, 26);

class Car
{
    public DateTime ShipDate;
}

Visual Studio에서는 target-typed new를 사용하도록 기존 code의 refactoring기능을 가지고 있습니다. 자세한 사항은 아래 link를 참고하시기 바랍니다.
https://learn.microsoft.com/en-us/visualstudio/ide/reference/use-new?view=visualstudio

Use new() - Visual Studio (Windows)

Learn how to use `new()` when you can't use `var`.

learn.microsoft.com

(4) 값 Type의 기본값

string을 제외하고 대부분의 원시 type은 값 type에 해당하며 값 type은 null이 될 수 없으므로 반드시 값을 가지게 됩니다. 변수에 기본값을 확인하기 위해서는 default() 연산자를 사용하여 type을 매개변수로 전달할 수 있고 반대로 기본값을 할당하는 경우에는 default keyword를 사용할 수 있습니다.

? 접미사를 사용하면 값 type인 경우에도 null을 가질 수 있는 상태로 만들 수 있습니다. 이에 관해서는 추후에 자세히 알아볼 테이지만 지금은 기본적으로 값 type은 null을 가지지 않은 것으로 이해해야 합니다.

string type은 new를 사용하지 않아 값 type으로 오인할 수 있지만 엄밀히 말하면 참조 type에 해당합니다. 그러므로 string의 변수는 실제 값을 가지고 있는 것이 아니라 값을 가진 heap memory의 주소값을 가지게 됩니다. string은 참조 type이므로 당연히 null상태가 될 수 있는데 null은 아직 어떤 것도 참조하고 있지 않은 상태임을 나타내며 모든 참조 type의 기본값이기도 합니다.

아래 예제는 int와 bool, DateTime과 같은 값 type의 기본값과 string의 기본값을 확인하고 있습니다.

Console.WriteLine($"int default : {default(int)}");
Console.WriteLine($"bool default : {default(bool)}");
Console.WriteLine($"DateTime default : {default(DateTime)}");
Console.WriteLine($"string default : {default(string) ?? "<NULL>"}");

예제에서 사용된?? 연산자는 피연산자가 null인 경우 오른쪽 값을 대신 반환하도록 하는 연산자입니다. 따라서 참조형인 string은 기본이 null상태이므로 'null'이라는 문자열을 표시하게 됩니다.

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제에서 시간에 대한 기본값은 현재 예제를 실행하는 PC의 문화권에 따라 다른 서식으로 표현될 수 있습니다.

아래 예제는 값 type에 기본값을 할당하는 방법을 나타내고 있습니다.

int number = 10;
Console.WriteLine($"current value 1 : {number}");
number = default;
Console.WriteLine($"current value 2 : {number}");

값 type에 아무런 값도 지정하지 않으면 기본적으로 기본값이 할당되지만 이를 명시적으로 나타내고자 하는 경우 예제에서와 같이 default keyword를 사용할 수 있습니다.

4. Console App

흔히 Console App이라 함은 문자기반의 command prompt에서 동작하는 Application을 말합니다. 문자열로 명령을 입력하며 문자열기반의 응답을 받기 때문에 macOS나 Windows의 UI(User Interface)따위는 존재하지 않습니다. 따라서 비교적 단순하며 빠른 응답을 필요로 하는 경우에 종종 사용되는 Application유형이라 할 수 있습니다. 또한 대부분의 경우 이러한 Application의 동작을 제어하기 위해 인수를 전달하는 방법이 많이 사용됩니다.

Console App의 한 가지 예로 Command prompt에서 dotnet 명령을 사용하는 경우를 들 수 있는데 새로운 Console App project를 생성하는 경우 기본적으로 folder의 이름을 사용하게 되지만 특정 project의 이름을 지정하고자 한다면 아래와 같이 dotnet명령을 사용할 수 있습니다.

dotnet new console -n myapp

1) 화면 출력

Console App에서 가장 빈번하게 수행되는 2가지 작업을 꼽으라면 data를 읽고 쓰는 것을 말할 수 있습니다. 우리는 이미 여러 예제에서 화면 출력을 위해 WriteLine method가 사용되는 것을 봐왔습니다. WriteLine method는 인수로 전달된 내용을 화면에 표시한 뒤 자동으로 carriage return을 수행하는데 만약 이러한 동작이 이루어지는 걸 원하지 않는다면 Write method를 대신 사용할 수 있습니다.

Console.Write("A");
Console.Write("B");
Console.Write("C");

위의 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

Write method는 자동개행(carriage return)을 수행하지 않으므로 인수의 문자열이 나란히 표시됨을 알 수 있습니다. 반면 WriteLine method를 대신 사용한다면 carriage return동작으로 인해 위와 다른 결과를 표시할 것입니다.

Console.WriteLine("A");
Console.WriteLine("B");
Console.WriteLine("C");

2) Numbered positional arguments(번호가 매겨진 위치 인수)를 사용한 서식화

Console App에서 서식화된 문자열을 표시하기 위해 사용되는 가장 흔한 방식으로 numbered positional arguments가 있습니다.

Numbered positional arguments는 Write나 WriteLine와 같은 method에서 지원하는데 문자열에서는 format method를 대신 사용할 수 있습니다.

아래 예제는 상품의 개수별 단가를 표시하는 것으로 상품의 개수와 단가표시를 위해 WriteLine method와 무너져 열변수에서 numbered positional arguments를 사용하고 있습니다.

int goods = 10;
decimal price = 1200;

Console.WriteLine(
    format: "상품 {0}개 : {1}원",
    arg0: goods,
    arg1: goods * price);

string howmuch = string.Format(
    format: "상품 {0}개 : {1}원",
    arg0: goods,
    arg1: goods * price);

Console.WriteLine(howmuch);

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제에서는 인수를 지정하기 위해 arg0과 arg1이라는 숫자가 매겨진 이름의 인수를 사용하였습니다. 기본적으로 이러한 인수는 arg2까지 3개를 사용할 수 있으며 그 이상의 인수를 지정해야 한다면 아래와 같이 인수명을 생략하고 인수를 지정해야 합니다.

Console.WriteLine(
    "Colors : {0}, {1}, {2}, {3}, {4}",
    "Red", "Blue", "Black", "Yellow", "Green");

3) 보간문자열(Interpolated strings)

보간문자열은 C#6부터 도입된 기능으로 사용하고자 하는 문자열의 앞에 아래 예제와 같이 '$'문자를 접두사로 붙이면 문자열 중간에 중괄호를 사용하여 해당 위치에 변수나 표현식의 현재 결괏값을 표현할 수 있습니다.

int goods = 10;
decimal price = 1200;

Console.WriteLine($"상품 수량 : {goods}, 단가 {price}원");

일반적인 문자열에서 보간문자열을 사용하면 해당 문자열을 더 쉽게 읽을 수 있다는 장점이 있습니다.

또한 이러한 특징의 보간문자열을 사용하면 문자열을 서로 결합하는 경우에도 유용하게 사용할 수 있습니다. 예를 들어 C#10 이전에는 문자열 결합을 위해 + 연산자를 사용하여 결합해야 했지만

string s1 = "abcd";
string s2 = "efgh";

string result = s1 + s2;

Console.WriteLine(result);

보간문자열을 사용하면 위의 예제를 아래와 같이 동일하게 사용할 수 있습니다.

string s1 = "abcd";
string s2 = "efgh";

string result = $"{s1}{s2}";

4) 서식 문자열

변수나 표현식은 comma나 colon을 통해 서식 문자열을 사용함으로써 서식화활 수 있습니다.

서식문자열은, 예를 들어 N0은 천 단위 분리와 함께 소수점이 없는 서식을 의미하며 C는 통화를 의미합니다. 통화와 관련된 서식은 현재 PC의 문화권설정에 따라 달라질 수 있습니다.

서식문자열을 사용할 때의 형식은 아래와 같습니다.

{ index [, alignment ] [ : formatString ] }

위 형식에서 alignment는 특정 문자수만큼의 간격으로 왼쪽 혹은 오른쪽으로 값을 정렬하고자 할 때 사용되며 정수값이 사용됩니다. 이때 정수값이 양수라면 오른쪽 기준 정렬을, 음수라면 왼쪽 기준 정렬을 수행합니다.

Console.WriteLine("Student Table");
Console.WriteLine("{0, -10} {1, -5} {2, 9}", "Name", "Class", "Age");
Console.WriteLine("{0, -8} {1, -5} {2, 5:N0}", "홍길동", "족구", 12);
Console.WriteLine("{0, -8} {1, -5} {2, 5:N0}", "장아영", "야구", 15);
Console.WriteLine("{0, -8} {1, -5} {2, 5:N0}", "황민경", "야구", 9);
Console.WriteLine("{0, -8} {1, -5} {2, 5:N0}", "김필석", "탁구", 11);
Console.WriteLine("{0, -8} {1, -5} {2, 5:N0}", "김동원", "축구", 10);

위 예제에서 Name, Class, Age column을 표시할 때 Name은 10자 기준 왼쪽정렬을, Class는 5자 기준 왼쪽정렬을, Age는 9자 기준 오른쪽 정렬을 수행하며 목록에서는 이름에 8 자 기준 왼쪽, 수업에는 5자 기준 왼쪽, 나이 부분에는 오른쪽 5자 기준 정렬을 수행하여 표시하도록 합니다. 이때 나이는 N0을 적용해 소수점 없이 표시하도록 하였으며 그럴 일이 없겠지만 나잇값이 1000이 넘으면 ,를 사용해 천 단위 분리를 적용할 것입니다.

5) 숫자 밑 날짜, 시간 서식화

숫자의 서식과 관련해서는 사용자 정의 서식 code를 사용함으로써 원하는 대로 표현방식을 지정할 수 있습니다. 아래 표에서는 사용가능한 서식 code와 그 용도를 확인할 수 있습니다.

0	0자리 표시자로 0이 아닌 값이 있다면 해당 값을 표시하지만 그렇지 않다면 0을 대신 표현합니다. 예를 들어 '0000.00'으로 서식화한 경우 '123.4'라는 값이 있으면 '0123.40'으로 표시됩니다.
#	자리 표시자로 0이 아닌 값이 있다면 해당 값을 표시하지만 그렇지 않다면 해당 자리수를 표현하지 않습니다. 예를 들어 '####.##'으로 서식화한 경우 '123.4'라는 값이 있으면 '123.4'로 표시됩니다.
.	소수점 표시자로 숫자에서 소수점을 나타내기 위해 사용됩니다. 문화권의 영향을 받으므로 소수점의 표현형태가 달라질 수 있습니다. 예를 들어 French 문화권이라면 소수점을 ,(comma)로 표시합니다.
,	그룹단위 분리자입니다. 보통 숫자에서 천단위 분리를 위해 많이 사용됩니다. 예를 들어 '0,000'서식일때 '123456789'라는 숫자가 있으면 '123,456,789'로 표시합니다. 또한 1000단위로 수를 나누어 숫자의 규모를 조정하는데에도 사용됩니다. 예를 들어 '0.00,,'으로 서식화한 경우 ,하나당 1000을 나눈다는 의미가 되므로 '1234567'값은 '1.23'으로 표시됩니다.
%	Percentage 자리표시자로 값을 100으로 곱하여 뒤에 percentage문자를 붙여줍니다.
\	확장문자로서 서식code뒤의 문자를 그대로 표시합니다. 예를 들어 '\##,###'으로 서식화한 경우 '1234'값이 있다면 '#1,234'로 표시합니다.
;	Selction분리자로서 양수, 음수, zero에 대한 서식문자열의 차이를 정의합니다. 예를 들어 '[0];(0);Zero'로 서식화한 경우 12값은 '[12]'로, -12값은 '(12)'로, 0은 'Zero'로 표시합니다.

상기 외에 사용가능한 다른 서식 code도 존재합니다. 모든 서식 code에 대한 목록은 아래 link를 참고하시기 바랍니다.
https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-numeric-format-strings\

Custom numeric format strings - .NET

Learn how to create a custom numeric format string to format numeric data in .NET. A custom numeric format string has one or more custom numeric specifiers.

learn.microsoft.com

숫자에 대한 서식은 'C'나 'N'과 같은 표준 서식을 사용하여 좀 더 간단하게 적용할 수도 있습니다. 이때도 'C0, N4'와 같이 정밀도를 조정하여 원하는 만큼의 정밀도를 표현할 수 있는데, C와 N에서는 아무런 숫자도 지정하지 않으면 기본값 2가 적용되지만 다른 서식 code의 영향으로 약간씩 달라질 수 있습니다. 특히 D 같은 경우, 기본정밀도가 필요로 하는 최소수이며 E에서는 6이 됩니다.

C, c	통화를 의미하며 문화권의 영향에 따라 다르게 표시될 수 있습니다. 예를 들어 대한민국문화권이라면 123.4값을 '￦123.4'로 표현합니다. 소수점을 무시하고자 하는 경우 'C0'으로 사용할 수 있으며 그 결과 '￦123'로 표시될 것입니다.
N, n	선택적 음수기호와 group화문자를 가진 정수자리수입니다.
D, d	10진수로 선택적 음수기호가 있지만 group화문자는 없는 정수자리수입니다.
B, b	2진수로 13과 같은 정수를 1101로 표현합니다.
X, x	16진수로 255와 같은 정수를 FF로 표현합니다.
E, e	지수표기법으로 1234.567과 같은 수를 1.234567000E+003으로 표현합니다.

상기 이외에 전체 표준서식은 아래 link에서 확인할 수 있습니다.
https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings

Standard numeric format strings - .NET

In this article, learn to use standard numeric format strings to format common numeric types into text representations in .NET.

learn.microsoft.com

단순 숫자뿐 아니라 아래와 같이 날짜와 시간에 대한 사용자 정의 서식 code도 사용할 수 있습니다.

/	날짜 분리자입니다. 문화권의 영향을 받아 다르게 표시할 수 있는데 예를 들어 미국 문화권이라면 '/'로 대한민국 문화권이라면 '-'문자로 표현됩니다.
\	확장문자로서 서식code뒤의 문자를 그대로 표시합니다. 예를 들어 'h \h m \m'이라면 오전 10:30분을 '10 h 30 m'으로 표시할 것입니다.
:	시간분리자로서 문화권의 영량을 받아 다르게 표시할 수 있습니다. 대한민국 문화권이라면 ':'이 사용되지만 French라면 '.'이 사용됩니다.
d, dd	날짜 표시자입니다. 기본적으로 1에서 31까지 날짜를 표시하는데 'dd'를 사용한다면 숫자가 하나일때 앞에 0을 부텅 '01'처럼 표현합니다.
ddd, dddd	요일을 표시합니다. 예를 들어 월요일인 경우 'ddd'라면 '월'로 표시하지만 'dddd'라면 '월요일'로 표시합니다.
f, ff, fff	10분의 1초, 백분의 1초(밀리초)를 나타냅니다.
g	'A.D'같은 시대를 표현합니다.
h, hh	시간을 나타냅니다. 1부터 12시를 표현하며 'hh'인 경우 숫자가 하나일때 앞에 0을 붙어 '01'과 같이 표현합니다.
H, HH	시간을 나타냅니다. 1부터 24시를 표현하며 'HH'인 경우 숫자가 하나일때 앞에 0을 붙어 '01'과 같이 표현합니다.
K	표준 시간대를 나타냅니다. 표준 시간대가 특정되지 않으면 null이 되며 UTC는 Z로 나타냅니다. UTC로 부터 조정된 지역 시간대는 -8:00과 같은 값으로 표현됩니다.
m, mm	0부터 59분까지 붙을 나타내며 'mm'이라면 숫자가 하나일때 앞에 0을 붙어 '01'과 같이 표현합니다.
M, MM	1부터 12까지 월을 나타내며 'MM'이라면 숫자가 하나일때 앞에 0을 붙어 '01'과 같이 표현합니다.
MMM, MMMM	월을 문자열로 표현합니다. 'MMM'이라면 'Jan'과 같이 표현하지만 'MMMM'이라면 'January'로 나타냅니다. 문화권의 영향을 받으므로 다르게 표현될 수 있습니다.
s, ss	0부터 59까지 초를 나타내며 'ss'라면 숫자가 하나일때 앞에 0을 붙어 '01'과 같이 표현합니다.
t, tt	오전, 오후를 나타내며 't'라면 'A'로 표현하지만 'tt'라면 'AM'으로 표현됩니다.
y, yy	0부터 99까지 세기(century)를 표현하며 'yy'라면 숫자가 하나일때 앞에 0을 붙어 '01'과 같이 표현합니다.
yyy	최소 3자리 숫자만큼의 년도를 표시하며 필요로 하는 만큼의 자리수를 가질 수 있습니다. 예를 들어 '1 A.D'는 '100'으로 표현되며 '2026'과 같은 년도표현도 가능합니다.
yyyy, yyyyy	4자리 혹은 5자리 수의 년도를 나타냅니다.
z, zz	UTC로 부터의 offset시간을 나타냅니다.
zzz	UTC로 부터의 offset 시간과 붙을 나타냅니다. 0으로 자리수를 채우므로 '+05:30'과 같이 나타냅니다.

날짜와 시간에 관한 더 자세한 목록은 아래 link에서 확인할 수 있습니다.
https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings

Custom date and time format strings - .NET

Learn to use custom date and time format strings to convert DateTime or DateTimeOffset values into text representations, or to parse strings for dates & times.

learn.microsoft.com

또한 날짜와 시간에도 아래와 같이 표준서식을 적용할 수 있습니다.

d	'2026-01-07'와 같이 날짜를 표현합니다. 문화권의 영향을 받으므로 다르게 표현될 수 있습니다.
D	'2026년 1월 7일 수요일'와 같이 날짜와 요일을 표현합니다. 문화권의 영향을 받으므로 다르게 표현될 수 있습니다.
f	'2026년 1월 7일 수요일 오후 4:28'와 같이 날짜와 요일, 시간을 표현합니다. 문화권에 따라 다르게 표현될 수 있습니다.
F	'2026년 1월 7일 수요일 오후 4:31:16'와 같이 날짜와 요일, 시간, 초를 표현합니다. 문화권에 따라 다르게 표현될 수 있습니다.
m, M	'1월 7일'과 같이 월과 날짜를 표현합니다. 문화권에 따라 다르게 표현될 수 있습니다.
o, O	날짜와 시간을 '026-01-07T16:32:42.9964891+09:00'과 같이 표준 pattern으로 표현합니다. 다른 쪽으로의 data전달을 위해 날짜와 시간값을 직렬화하는데 유용합니다.
r, R	RFC1123 pattern으로 표현합니다.
t	'HH:mm' 형식으로 짧은 시간을 표현합니다. 문화권에 따라 다르게 표현될 수 있습니다.
T	'HH:mm:ss' 형식으로 긴 시간을 표현합니다. 문화권에 따라 다르게 표현될 수 있습니다.
u	'2026-01-07 16:38:32Z'와 같이 범용 짧은 날짜/시간 pattern으로 표현합니다.
U	'2026년 1월 7일 수요일 오전 7:39:19'와 같이 범용 긴 날짜/시간 pattern으로 표현합니다.

날짜와 시간에 관한 더 자세한 표준서식 목록은 아래 link에서 확인할 수 있습니다.
https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings

Standard date and time format strings - .NET

Learn how to use a standard date and time format string to define the text representation of a date and time value in .NET.

learn.microsoft.com

6) Console 사용 간소화하기

C#6부터 using문은 namespace를 import 할 뿐만 아니라 정적 class를 import 함으로써 code작성 자체를 간소화하는데도 사용할 수 있습니다. Console class도 마찬가지인데 using문을 사용하면 Console의 입력을 반복할 필요가 없습니다.

(1) 단일 file에서 정적 type import 하기

예를 들어 Program.cs라면 해당 file의 상단에 아래와 같이 using문을 추가하여 System.Console class에 대한 정적 import를 수행할 수 있습니다.

using static System.Console;

그러면 이후부터는 해당 file에서 아래와 같이 WriteLine와 같은 Console method를 Console 없이 호출할 수 있습니다.

WriteLine("...");

(2) Project단위 정적 type import 하기

정적 import는 단일 file이 아닌 Project단위 모든 file을 위해서도 적용할 수 있습니다.

Program.cs에서 이전에 작성한 using문 전체를 삭제하고 Project의 설정 file(csproj)을 열어 <PropertyGroup> 다음에 <ItemGroup>을 추가하고 그 안에 아래와 같이 Using 요소를 추가함으로써 System.Console을 전역적으로 import 할 수 있습니다.

<ItemGroup Label="Console static import">
    <Using Include="System.Console" Static="true" />
</ItemGroup>

위 예제에서 ItemGroup안에 있는 label속성은 일부 요소에 대한 주석화가 필요할 때 또는 다수의 이 사용되는 경우 각 의 역할을 명확하게 구분하는데 유용하게 사용할 수 있지만 필수속성은 아닙니다.

7) 입력받기

화면을 표시하기 위해서는 WriteLine method를 사용하지만 반대로 사용자로부터의 입력은 ReadLine method를 사용하며 이를 통해 입력된 문자열값을 받을 수 있습니다. ReadLine method가 호출되면 사용자가 값을 입력할 때까지 대기상태에 있다가 사용자가 입력을 마치면(원하는 입력 후 Enter key를 누르는 순간) 그동안의 입력한 값을 문자열로 반환합니다.

아래 예제는 사용자에게 이름과 나이의 입력을 요청한 뒤 사용자가 값을 입력하고 나면 해당 값을 그대로 화면에 표시하도록 합니다.

Console.WriteLine("이름을 입력하세요.");
string name = Console.ReadLine();
Console.WriteLine("나이를 입력하세요.");
string age = Console.ReadLine();

Console.WriteLine($"귀하의 이름은 {name}이고 나이는 {age}입니다.");

.NET 6부터는 null가능성 확인기능이 기본으로 동작하므로 위 예제라면 ReadLine method가 null을 반환할 수 있다는 compiler의 경고를 표시할 수 있습니다. 그러나 실질적으로 ReadLine method가 null을 반환할 수 있는 상황은 발생하지 않습니다. 사용자가 아무런 값을 입력하지 않는다 하더라도 빈문자열 값을 반환할 뿐 null을 반환하는 경우는 없습니다. 필요하다면 특정한 경우에 이러한 null확인기능이 동작하지 않도록 할 수 있는데 이에 대한 구체적인 방법은 곧 알아볼 것입니다.

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다. 결괏값은 입력한 값에 따라 달라집니다.

null가능성 경고와 관련하여 예제의 'string name = Console.ReadLine();'부분에서는 아래와 같이 string뒤에 '?'문자를 접미사로 붙여줄 수 있습니다.

string? name = Console.ReadLine();

위의 경우는 compiler에게 name변수가 null이 될 수 있음을 알고 있다고 명시함으로써 compiler가 null가능성 경고를 표시하지 않도록 합니다. 하지만 이미 상술했듯이 ReadLine이 null을 반환하는 경우는 없으므로 예제는 아무런 문제 없이 작동할 수 있습니다. 그러나 만약 위 상태에서 name변수의 특정 member에 접근을 시도하게 되면 compiler는 다시 null가능성 경고를 표시할 수 있습니다. 상기 처리는 compiler에게 'name변수가 null이 될 수 있음을 알고 있어. 그러니 경고표시는 하지 말아 줘.'라고 compiler에게 요청하는 것일 뿐 실제 name이 null이 되지 못하도록 하는 조치는 아닙니다. 때문에 여전히 name변수가 null이 될 수 있는 상황에서 member의 접근은 적절한 처리가 아니므로 compiler의 경고를 보게 되는 것입니다. 만약 이와 같은 상황에서 'name변수가 어떠한 경우에도 null이 되지 않는다.'라는 걸 명시하고자 한다면 아래와 같이 '!'문자를 ReadLine method뒤에 붙여줄 수 있습니다.

string name = Console.ReadLine()!;

위 예제에서 '!'표시는 compiler에게 'ReadLine method는 절대 null을 반환하지 않을 거야.'라고 알려주는 것입니다. 따라서 '그 결과를 받는 name변수도 null 되는 경우는 없다.'라는 의미가 되고 따라서 compiler는 상기 처리에 대해서 null가능성 경고를 표시하지 않게 됩니다. 이를 'null 허용 연산자'라고 하는데 다만, 정말 ReadLine method가 null을 반환하게 되는 상황 즉, name변수가 null이 되는 상황이 발생하는 경우에 대한 모든 책임은 직접 개발자에게 있음을 알고 있어야 합니다.

위 2가지 방법을 통해 compiler가 발생시키는 null가능성 경고를 어떻게 처리할 수 있는지를 간단히 알아봤는데 추후에 null과 관련된 더 자세한 처리방법을 알아볼 것입니다.

ReadLine method 자체가 null을 반환하는 경우는 있을 수 있습니다.

ReadLine method는 표준입력 stream으로부터 입력값을 받게 되는데 상술했듯 사용자가 아무런 값도 입력하지 않고 Enter를 누르게 되면 null대신 빈 문자열값을 반환합니다.

Console App에서 일반적인 경우 ReadLine이 null을 반환하는 건 EOF(end of stream)에 도달한 경우뿐입니다. 그러나 이 경우는 표준입력 stream이 redirect 되거나 EOF에 도달한 경우 또는 EOF를 임의적으로 만들어낼 수 있는 환경에서만 발생가능한 것일 뿐 단순 사용자 입력으로는 '절대!'발생하지 않습니다.

(1) key 입력 여부 판별하기

ReadKey method를 사용하면 사용자로부터 특정 key의 입력을 판별할 수 있습니다. 해당 method는 사용자의 key입력을 대기하다가 특정 key나 혹은 여러 key를 누르게 되면 그에 해당하는 ConsoleKeyInfo값을 반환합니다.

아래 예제는 사용자에게 key의 입력을 요청하고 사용자가 원하는 key입력을 수행하면 그에 해당하는 key의 정보를 표시하도록 합니다.

Console.WriteLine("원하는 key를 눌러주세요.");
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
Console.WriteLine($"{key.Key} : {key.KeyChar} : {key.Modifiers}");

예제를 실행하면 다음과 같은 결과를 표시할 것입니다. 예제에서는 key입력에 Alt + h key를 누른 것입니다.

ConsoleKeyInfo에서 key속성은 입력한 key의 값을, KeyChar는 입력한 key의 문자를 의미합니다. 따라서 만약 F3이나 F12와 같은 key를 누른 경우라면 이 값은 나오지 않을 수 있습니다. 마지막으로 Modifiers는 Alt나 Shift key와 같이 다른 key와의 조합을 의미합니다.

VSCode안에서 Console App을 실행하는 경우 일부 key의 입력은 실행 중인 Console App에 도달하기도 전에 VSCode안에서 가로채 VSCode의 특정기능으로 실행될 수 있습니다. 예를 들어 Ctrl + Shift + X key는 VSCode에서 Extensions보기기능에 해당합니다. 따라서 Console App에서 제대로 key의 입력을 test 해 보려면 Console App을 Build 하고 Command Prompt 또는 Terminal에서 Compile 된 exe를 실행해야 합니다.

8) 인수 전달하기

Console App의 동작은 대게 필요한 인수를 전달함으로써 제어합니다. 예를 들어 dotnet의 명령줄도구에서 특정 template의 project를 생성하려면 아래와 같이 해당 project template의 이름을 전달합니다.

dotnet new Console

위와 같은 방식으로 console ppp이 실행되면 사용자가 전달한 인수값을 application안에서 추출해야 할 필요가 있습니다. .NET6 이전에 console app project template은 기본적으로 아래와 같은 code를 생성했는데

using System;

namespace Arguments
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

위 code에서 Main method에 있는 'string[] args'가 바로 인수를 저장하고 있는 매개변수에 해당하며 array type이므로 해당 매개변수를 통해 인수값을 순서대로 확인할 수 있습니다.

.NET6 이후부터는 top-level programs가 사용되므로 상기 예제와 같이 Program class와 Main method가 노출되지 않습니다. 따라서 얼핏 보면 args인수 역시 존재하지 않는 것처럼 보일 수 있으나 이러한 요소들은 눈에만 보이지 않고 감춰져 있을 뿐 여전히 존재하므로 사용되지 않는다고 오해해서는 안됩니다.

명령줄에서 인수는 오로지 공백으로만 분리되며 이렇게 분리된 인수값이 args배열에 순서대로 들어가게 됩니다. 만약 인수값 자체에 공백이 포함되어야 한다면 이때는 홑따옴표나 큰따옴표로 인수값 자체를 감싸서 표현해야 합니다.

아래 예제는 top-level programs환경에서 전달된 인수의 개수를 확인하고 있습니다.

Console.WriteLine($"전달된 인수의 수 : {args.Length}");

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

만약 위 예제를 Visual Studio에서 실행하고자 한다면 인수를 조금 다른 방식으로 지정해야 합니다.

Visual Studio의 Solution Explorer에서 project를 mouse오른쪽 click 하고 Properties를 선택합니다. 그런 후 설정화면의 왼쪽에 Debug 항목을 선택하고 'Open debug launch profiles UI'를 선택합니다.

'Launch Profiles'화면의 'Command line arguments'부분에 원하는 매개변수를 공백으로 분리하여 순서대로 입력합니다.

위와 같이 설정하고 'Launch Profiles'화면을 닫으면 Solution Explorer에는 'Properties'folder와 함께 하위에 launchSettings.json file이 생성되는데, 해당 file을 선택해 열어보면 위에서 설정한 인수값이 그대로 commandLineArgs로 등록되어 있음을 알 수 있습니다.

{
  "profiles": {
    "ConsoleApp1": {
      "commandName": "Project",
      "commandLineArgs": "aaa bbb ccc"
    }
  }
}

전달된 인수의 실제 값을 확인하기 위해 Program.cs에서 Console.WriteLine... 다음에 아래와 같은 구문을 추가하고

foreach (string arg in args)
{
    Console.WriteLine(arg);
}

다시 예제를 실행시키면 아래와 같은 결과를 표시할 것입니다.

(1) 인수 활용하기

아래 예제는 Console App을 통해 현재 실행중인 terminal의 전경색과 배경색을 변경하도록 합니다.

우선 현재 필요한 인수는 총 2개이므로 만약 사용자가 23개의 인수를 제대로 입력하지 않은 경우 사용자에게 관련 오류를 표시하고 application의 실행을 중지하도록 합니다.

if (args.Length < 2)
{
    Console.WriteLine("프로그램 실행에 필요한 충분한 인수가 지정되지 않았습니다.");
    return;
}

만약 인수가 2개나 그 이상입력된 경우라면 첫 번째 인수값부터 읽어 terminal의 전경색과 배경색, cursor의 크기를 설정하도록 합니다. 인수가 2개 이상 지정된 경우라면 그 이상은 어차피 무시할 것이므로 문제 되지 않습니다.

Console.ForegroundColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), args[0], true);
Console.BackgroundColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), args[1], true);

예제에서 사용된 ForegroundColor나 BackgroundColor 외에도 CursorSize와 같이 terminal에 관련된 여러 속성이 제공됩니다. 다만 일부 속성의 경우는 Windows전용이므로 다른 OS에서 다른 속성을 사용하고자 하는 경우 compiler경고가 발생할 수 있고 실제 Application이 실행되는 경우 예외가 발생할 것입니다.

Enum.Parse, typeof와 같은 생소한 구문은 추후에 자세히 알아볼 것입니다.

예제를 실행하기 위해 아래와 같이 2개의 인수를 지정하여 실행하면 다음과 같은 결과를 표시할 것입니다.

[C# 14 / .NET 10] 2025년 11월 C# 14 탄생

클리엘 — Thu, 6 Nov 2025 16:31:36 +0900

2025년 11월 기다리던 C#의 14번째 version과 .NET 10이 출시되었습니다. 새로움은 늘 기대로 가득한 채 변화를 맞이하게 하지만 그만큼 새롭게 알아야 할 것들이 생겨나게 마련이고 그런 이유로 새로운 것을 찾아보기 위한 여정을 지금부터 시작하고자 합니다.

다른 언어도 모두 마찬가지 겠지만 Software개발을 위해서는 그 맞는 개발환경을 갖추어야 할 것입니다. C# 역시 이 과정이 필요하므로 우선 Visual Studo 2026과 Visual Studio Code를 사용해 개발환경을 만들어볼 것입니다.

향후 개발 도구의 명칭은 Visual Studio 2026를 VS2026으로 Visual Studio Code를 VSCode로 지칭하고자 합니다.

하지만 개발환경을 갖춘다고 아무것도 모른채로 바로 시작할 수 있는 것은 아니니 .NET에 대한 기본적인 개념을 잡고 가야 할 것입니다. 사실 .NET이란걸 단편적으로는 설명할 수 없고 대신 여러 가지 얘기가 나와야 하는데, 그렇다고 해서 복잡한 얘기를 할 필요는 전혀 없습니다. 단순히 기본적인 개념을 잡는 것으로 시작해 VS2026과 VSCode를 사용하여 C# 14와 .NET 10을 대상으로 한 예제를 만들어 봄으로서 한 걸음씩 나아갈 것입니다.

1. 개발환경 설정

Programming을 하려면 당연히 그에 맞는 개발도구를 갖추고 있어야 합니다. 물론 notepad와 같은것만으로도 불가능한 것은 아니지만 작업의 효율성은 극히 떨어질 것입니다.

C#을 위해 사용할 수 있는 대표적인 개발도구로는 당연 VS2026이나 VSCode를 그 예로 들 수 있습니다. 물론 이외에도 jetBrains사의 Rider등을 사용할 수 있지만 VS2026와 VSCode 외에 다른 개발도구에 관해서는 따로 언급하지 않을 것입니다.

VS2026은 이것 하나만으로 정말 많은 작업을 수행할 수 있으며 대부분의 .NET개발자가 사용하는 개발도구이기도 합니다. 하지만 많은 것을 수행할 수 있는 만큼 VSCode에 비해 크고 복잡한 구조를 가진다는 단점이 있습니다. 뿐만 아니라 대부분의 작업에서 자체적인 mechanism을 제공함으로써 뒷단에 발생하는 많은 동작을 감추고 있고, 그 결과로 드러나는 것만 개발자에게 보여주는 경향이 있습니다. 이러한 동작방식은 숙련된 개발자에게는 상당한 편리함을 제공해 주지만 학습을 시작하고자 하는 초보개발자에게는 오히려 세부적인 동작원리를 감추게 됨으로써 학습효과를 저해하는 결과를 가져다줄 수 있습니다.

극단적으로 설명하자면 사실 project의 설정이나 code file을 편집하기 위해서는 반드시 VS2026과 같은 개발도구가 필요한 것은 아닙니다. 이미 언급했듯 notepad만으로도 code를 작성할 수 있고 dotnet command-line 도구를 사용하여 해당 file을 compile하고 실행할 수 있습니다. 개발도구는 단지 이러한 과정에서 직접 처리해야만 하는 수많은 작업과정을 대신해 주는 도구의 역할만을 해줄 뿐입니다.

1) 학습을 위한 적절한 도구와 project type

Programming을 처음 시작하는 경우, 사용할 가장 좋은 개발도구는 code의 입력과 설정과정을 적절하게 도와주면서도 뒷편에서 발생하는 동작을 감추지 않는 것입니다. 개인적으로 현재 시점에서 이러한 조건에 가장 부합해 있는 개발도구가 바로 VSCode라고 판단됩니다. 아직 어떤 개발도구를 사용할지 결정하지 않았다면 VSCode를 강력히 권장합니다.

VSCode는 권장사항일뿐 이미 익숙하게 사용하고 있거나 소속되어 있는 Team에서 사용 중인 별도의 개발도구가 있는 경우 해당 도구를 계속할 수 있습니다. Programming에서 개발도구의 선택범위는 제한이 없으므로 특정 개발도구의 사용을 고집할 필요는 없습니다.

.NET에서 생성할 수 있는 Application유형은 Desktop수준부터 Web에 이르기까지 매우 다양합니다. 단순히 C# Programming을 경험하기 위한 것이라 해도 예제를 위한 Project를 특정 Application 유형으로 생성해야 하는데, 이를 위해 특별한 경우가 아니면 모두 Console Application Project Teamplate을 사용할 것입니다. Console Application은 학습에 불필요한 Code를 수반하지 않으면서 학습에만 집중할 수 있게 하는 가장 좋은 Application유형이라 말할 수 있습니다.

(1) Visual Studio Code

VSCode는 Microsoft에서 개발된 가벼우면서도 훌륭한 성능을 제공하는 code editor이며 무엇보다 cross-platform에 해당하므로 Windows는 물론 macOS나 Ubuntu, Red Hat과 같은 Linux에서도 실행할 수 있습니다. 이렇게 다양한 platform을 지원하게 됨으로써 자연스럽게 cross-platform app을 개발하는 데 사용되고 있으며 Hardware 역시 기존 x86 processor뿐만 아나라 ARM까지도 지원함으로써 Apple Silicon 계열 및 Surface Laptop, 심지어 Raspberry Pi 등 ARM을 기반으로 한 다양한 장치에서도 실행하고 관련 App을 개발할 수 있습니다.

뿐만 아니라 .NET/C#차원을 넘어 다양한 언어와 개발보조를 위한 수많은 확장기능까지 원하는 대로 설치하여 활용할 수 있습니다. 이중에서 .NET/C#개발자에게 가장 중요한 C# Dev Kit이 존재하는데 이 확장도구는 일반적인 VSCode를 .NET/C#개발을 위한 최적의 도구로 전환시켜 줌으로써 VSCode를 훌륭한 .NET/C#개발을 위한 도구로서 활용할 수 있습니다.

C# Dev Kit에 관한 더 자세한 사항은 아래 link를 참고하시기 바랍니다.
https://devblogs.microsoft.com/visualstudio/announcing-csharp-dev-kit-for-visual-studio-code/

VSCode는 엄밀히 말해 범용으로 다양하게 활용될 수 있지만 현재 개발분야에서 가장 강력한 지원체계를 갖고 있는 분야가 바로 Web개발입니다. 아직까지는 web분야외에 mobile이나 desktop분야에서 해당 platform의 전용개발도구에 밀리는 경향이 있지만 그럼에도 불구하고 전 세계에서 가장 인기 있는 code editor로 자리 잡고 있습니다.

(2) GitHub Codespaces

GitHub Codespaces는 VSCode에 기반한 개발환경으로서 겉으로 보이에는 이 둘 사이에 거의 차이점이 없어 보일 수 있습니다. 그러나 Web상에서 구동된다는 근본적인 이점을 가지고 있으므로 web browser가 있고 internet에 접속할 수만 있다면 어디서든 접근가능한 Cloud개발을 경험해볼 수 있습니다. Git repository와 내장된 command-line interface 및 확장기능 역시 그대로 지원하므로 VSCode와 동일하게 code를 편집하고 실행할 수 있으며 다양한 device상에서 test 역시 가능합니다. 하지만 무료인 VSCode와는 달리 정말 쓸모 있는 code editor로서 유용하게 사용하려면 license비용을 지불해야 합니다.

GitHub Codespaces에 관한 더 자세한 사항은 아래 link를 참고하시기 바랍니다.
https://github.com/features/codespaces

(3) Visual Studio

Visual Studio는 desktop뿐만 아니라 Web분야까지 다양한 유형의 application을 개발할 수 있는 IDE라고 할 수 있습니다. 그러나 현재는 Windows운영체제에 한정되어 있으므로 macOS나 Linux상에서는 사용할 수 없다는 단점이 있습니다. 물론 VS2026을 사용해 cross-platform을 위한 Android와 iOS의 mobile app개발을 시작할 수 있지만 각각의 platform을 위한 compile을 위해서는 여전히 해당 platform상에서의 개발환경을 필요로 합니다.

본래 macOS에서 .NET을 위한 Visual Studio가 존재했었습니다. 하지만 .NET 8부터 더 이상 공식적으로 지웒하지 않게 되었으며 현재로서는 Visual Studio가 아닌 macOS용 VSCode를 사용하는 것이 대안으로 제시되고 있습니다. 또는 Paralles와 같은 가상화를 통해 Windows용 Visual Studio를 사용하는 방법도 있습니다. macOS용 Visual Studio의 지원종료에 관한 내용은 아래 link에서 확인할 수 있습니다.
https://devblogs.microsoft.com/visualstudio/visual-studio-for-mac-retirement-announcement/

2) Windows에서의 Linux Application개발

Windows에서 Linux를 대상으로한대상으로 한 Application개발에는 WSL를 빼놓을 수 없습니다. WSL(Windows Subsystem for Linux)은 개발자들이 cross-platform개발을 위해 사용할 수 있는 가장 강력한 도구라 할 수 있습니다. 가상화나 별도의 OS를 설치할 필요 없이 Windows안에서 일반적인 Linux환경을 직접 구동시킬 수 있는 것인데 이를 통해 VS2026과 같은 Windows작업환경을 벗어나지 않으면서 Linux를 대상으로한 .NET Application을 직접 test 하고 build 하고 debuging 할 수 있습니다. 즉, Windows상에서 filesystem이나 대소문자구분, 권한, 경로문자와 같은 Linux의 고유한 특징 및 기능 등을 사전에 검토하여 Linux호환 .NET Code를 작성하는 것이 가능한 것입니다.

WSL자체가 Linux kernel을 기반으로 하는 Linux를 구동시키는 것이기 때문에 .NET Application을 실제 Linux상에서 실행시키는 것이라 볼 수 있으며 이는 Linux를 대상으로 배포하고자 하거나 Linux Shell에서 Application의 동작을 직접 확인해 보고자 할 때 유용하게 사용할 수 있습니다. 실제 Linux와 동일한 환경이므로 curl, grep, awk, sed, bash과 같은 Linux개발도구를 직접 사용할 수 있고 심지어 다른 개발도구나 의존성을 설치하기 위한 apt 등의 package manager를 사용할 수도 있습니다.

Windows상에서 WSL을 설치하는 자세한 방법은 아래 link를 참고하시기 바랍니다.
https://learn.microsoft.com/en-us/windows/wsl/install

3) .NET 10의 지원 Platform

.NET 10은 아래 Platform을 지원하고 있으므로 해당 Platform을 대상으로 한 Application을 개발하고 배포할 수 있습니다.

OS	Version
Windows	Windows 10(1607 이후), Windows 11(22000 이후), Windows Server(2012R2 SP1 이후), Nano Server(2019 이후), Microsoft Surface Pro 11, Surface Laptop 7과 같은 Windows ARM기기 지원
Linux	Alpine Linux 3.22, Azure Linux 3.0, CentOS Stram 9/10, Debian 12/13, Fedora 42, openSUSE Leap 15.6, Redhat Linux 9/10, SUSE Enterprise Linux 15.6, Ubuntu 22.04/24.04/25.04
Android	최소 API 21 이상, Version 12, 12.1, 13, 14, 15
iOS	iOS 12.2
Mac	macOS 14/15

지원가능한 OS 및 Version에 관한 가장 최신의 정보는 아래 link를 참고해 주시기 바랍니다.
https://github.com/dotnet/core/blob/main/release-notes/10.0/supported-os.md

또한 .NET의 모든 version은 Windows의 자동 Update를 통해 최신상태를 유지할 수 있습니다.

4) VS2026 내려받고 설치하기

많은 .NET개발자들이 사용하는 가장 주된 개발도구라 함은 단연코 Visual Studio라고 할 수 있습니다. 같이 사용하게 될 VSCode는 범용이지만 Visual Studio는 오로지 .NET을 위한 전용의 개발도구라 할 수 있습니다. 향후 만들게 될 많은 예제는 VSCode만으로도 작성이 가능하겠지만 가능하다면 Visual Studio도 같이 사용해 볼 것을 권장합니다.

Visual Studio중에서 가장 최신의 version은 2025년 11월 출시한 Visual Studio 2026(이하 VS2026)이며 .NET10을 공식적으로 지원하는 유일한 개발도구이기도 합니다. Visual Studio는 Professional, Enterprise와 같이 여러 version이 존재하는데 2014년 10월부터 학생이나 open source 기여자, 개인에 한해 무료로 제공되고 있는 Community Edition도 존재합니다. Community는 Professional과 거의 비슷한 기능을 제공하면서도 무료로 배포되고 있으므로 학습을 위한 목적으로 가장 알맞은 Visual Studio version이라 할 수 있습니다. 향후 예제를 만드는 경우에도 Community Edition을 사용할 것이며 그중에서 가장 최신 version인 Visual Studio 2026를 사용할 것입니다.

VS2026은 아래 link를 통해 내려받을 수 있습니다.

https://visualstudio.microsoft.com/downloads/

내려받은 file을 실행하고 잠시 기다리면 다음과 같은 화면을 볼 수 있습니다.

위 화면의 Workloads에서 학습에 필요한 아래 항목을 선택합니다.

① ASP.NET and web development
② .NET disktop development

1번은 기본적인 web개발을 위한 것이며 2번은 console app을 포함한 일반적인 응용 program개발을 위한 것입니다.

위의 항목을 선택한 뒤 Install button을 click 하고 관련항목이 설치될 때까지 잠시 기다려 줍니다. 설치가 완료되고 처음 VS2026을 실행하면 다음과 같이 login화면이 나오게 되는데

만약 Microsoft계정이 있다면 해당 계정을 통해 login하면 되고 없다면 새로운 계정을 생성할 수 있습니다.(굳이 login을 하지 않더라도 하단의 'Skip and add accounts later.'를 선택하면 별도의 login 없이 VS2026을 사용할 수는 있으나 기능의 완전한 사용을 위해 login을 권장합니다.)

해당 과정을 넘기면 그 뒤로 기본적인 환경설정화면이 나오게 되는데 여기서는 Development Settings에 C#이나 General을 선택하고 Color theme부분에는 원하는 색상의 theme를 선택합니다. 모든 설정이 완료되고 나면 'Start Visual Studio'를 click 해 VS2026을 실행합니다.

5) VSCode 내려받고 설치하기

VSCode는 지난 몇년동안 가장 빠르게 발전한 code editor일 것입니다. 만약 자신의 Coding작업에 VS2026을 사용하기로 결정했다 하더라도 VSCode를 반드시 사용해 보길 권장합니다. 실제 어떤 걸 사용할지는 Visual Studio나 VSCode를 모두 사용해 본 다음에 결정해도 충분할 것입니다.

VSCode를 설치하고 사용하기 위해서는 몇가지 사전 절차가 필요한데 가장 중요한 VSCode부터 내려받고 설치하는 것으로 시작합니다.

VSCode는 아래 link에서 내려받을 수 있습니다.

https://code.visualstudio.com/

VSCode는 내려받고 설치가능한 version으로 안정화 version과 insider version을 제공하고 있는데 insider는 다음 version에 대한 미리 보기로 update주기가 잦으며 최신의 VSCode를 사용할 수 있지만 대신 안정성은 안정화 version에 비해 떨어질 것입니다. 특별한 경우가 아니라면 안정화 version을 내려받는 것이 좋습니다.

VSCode의 설치에 대한 자세한 guide는 아래 link에서 찾아 볼 수 있습니다.

https://code.visualstudio.com/docs/setup/setup-overview

VSCode와 함께 .NET SDK도 설치할 필요가 있습니다. 가장 최신 version은 .NET 10으로 만약 위에서 VS2026을 설치했다면 이미 .NET 10 SDK가 설치되어 있을 것이므로 이 과정은 넘어가도 좋습니다. 만약 그렇지 않다면 아래 link에서 .NET 10 SDK를 내려받아 설치합니다.

https://dotnet.microsoft.com/en-us/download

경우에 따라 .NET8, .NET9, .NET10등 다수의 .NET version이 설치되어 있을 수 있습니다. 이러한 경우는 아무런 문제가 되지 않으며 project를 build 할대 어떤 걸 사용할지 직접 정할 수 있습니다. 참고로 .NET8, .NET9, .NET10 version이 2025 이후로도 계속 지원되는 version에 해당합니다.

.NET SDK를 설치하고 나면 VSCode를 위해 'C# Dev Kit'확장기능을 설치합니다. 이를 위해 VSCode를 실행하고 Extensions를 선택하거나 View -> Extensions menu를 선택하고 'C#'을 입력하면 확장기능목록에 C# Dev Kit이 나오게 됨을 알 수 있습니다. 여기서 해당 항목을 선택해 확장기능을 설치합니다.

(1) 다른 확장기능 설치

VSCode에서 사용가능한 수많은 확장기능 중에는 'C# Dev Kit' 이외에 C#개발에 도움을 줄 수 있는 다른 확장기능이 존재합니다. 기본적으로 아래와 같은 확장기능을 추가로 설치하면 C#을 위한 VSCode로서 그 효율성을 향상할 수 있습니다.

C# Dev Kit (ms-dotnettools.csdevkit)	Microsoft의 공식 C#확장기능으로서 C#/.NET개발에서는 필수입니다. Solution Explorer를 통해 Code를 관리를 지원하며 통합된 단위 TEST 탐색 및 실행기능으로 Code를 test할 수도 있습니다. 이 밖에 C#개발에 필요한 다양한 기능을 지원하고 있으므로 C#개발경험을 향상시킬 수 있습니다.
C# (ms-dotnettools.csharp)	C#에 특화된 기능을 제공하기 위한 것으로 IntalliSense와 code탐색, debugging기능 지원등을 통해 더 빠르고 안정적인 C#개발경험을 제공합니다. 'C# Dev Kit'을 설치했다면 해당 확장기능은 따로 설치할 필요 없습니다.
IntelliCode for C# Dev Kit (ms-dotnettools.vscodeintellicode-csharp)	C#(TypeScript나 JavaScript등 기타 다른 언어 포함)언어를 위한 AI 지원 개발기능을 제공합니다.
ilspy-vscode (icsharpcode.ilspy-vscode)	MSIL로 구성된 assembly를 decompile하기 위한 것으로 가장 최신의 .NET뿐만 아니라 .NET Framework, ,NET Core, .NET Standard등에서도 사용할 수 있습니다.

또한 VS확장기능은 VSCode안에서 뿐만 아니라 Terminal에서도 아래 명령을 통해 설치할 수 있습니다.

명령	설명
code --list-extensions	설치된 확장기능 나열
code --install-extension </extension id>	지정한 id의 확장기능 설치 (ex : code --install-extension ms-dotnettools.csdevkit)
code --uninstall-extension	지정한 id의 확장기능 삭제

2. NET

.NET은 개발초기 단계에서부터 현재에 이르기까지 .NET Framework나 .NET Standard, .NET Core와 같은 platform의 등장을 통해 발전해 왔었음을 알 수 있습니다. .NET Framework시기부터 함께해 온 개발자라면 .NET의 역사에 익숙하겠지만 그렇지 않은 개발자도 있을 것입니다. 과거가 중요하지 않다는 말은 아니지만 굳이 여기서 .NET의 역사를 되짚어 볼 생각은 없습니다. 만약 이러한 것이 관심이 있다면 아래 Link를 통해 간략히 확인해 보실 수 있습니다.

[.NET/C#] - [C# 12와 .NET 8] 2. C#

1) .NET의 지원체계

.NET의 생명주기와 관련된 version은 크게 3가지로 나누어 볼 수 있습니다. 하나는 LTS(Long-Term Support)이고 다른 하나는 STS(Standard-Term Support)이며 나머지 하나는 Preview입니다. 그리고 이들 각각은 아래와 같은 지원가능한 주기를 갖고 있습니다.

Release	Support
LTS	GA(General Availability)이후 3년간 또는 다음 LTS가 발표된 이 후 1년중 더 긴쪽으로 지원되는 version입니다. 지원기간 동안 보안과 안정성에 관한 patch가 지속적으로 이루어집니다.
STS	GA이후 2년간 또는 다음 STS 나 LTS가 발표된 이 후 1년중 더 긴쪽으로 지원되는 version입니다. 지원기간 동안 보안과 안정성에 관한 patch가 지속적으로 이루어집니다.
Preview	공개 TEST용으로 사전에 신규기능이나 기술에 접근해 보고자 하는 개발자를 위한 version입니다. Preview자체가 실제 지원되는 version은 아니지만 어떤 Preview 또는 RC(Release Candidate)의 경우 Go Live로 결정되어 Microsoft에서 정식 제품으로 지원되는 경우도 있습니다. 그러나 만약 Preview를 통해 Application을 개발한 뒤에 바로 Go Live로 전환되었다 하더라도 가능한한 빠른 시간안에 migration을 진행해야 합니다.

STS는 경우에 따라 'Current'라고 표기되기도 합니다.

2025년 9월 Microsoft는 현재 STS의 지원기간이 18개월에서 24개월로 늘어날 수 있음을 공지한 바 있습니다. 관련된 내용은 아래 link를 참고하시기 바랍니다.
https://devblogs.microsoft.com/dotnet/dotnet-sts-releases-supported-for-24-months/

.NET STS releases supported for 24 months - .NET Blog

.NET STS releases will be supported for 24 months

devblogs.microsoft.com

가능한한 주기적인 Patch를 통해 .NET의 최신상태를 유지하시기 바랍니다. 예를 들어 .NET Runtime 10.0.0 version이 설치되어 있고 이후 10.0.1 version이 release 되었다면 지속적인 지원을 받기 위해 10.0.1을 설치하는 것이 좋습니다. 이러한 update는 매달 둘째 주 화요일인 Patch Tuesday에 release 됩니다.

STS와 LTS 간 지원기간에 대한 구분을 좀 더 명확히 확인하기 위해 아래 표를 참고해 주시기 바랍니다. 표에서 붉은색은 3년 녹색은 2년간의 지원기간을 의미합니다.

.NET 10의 지원기간 동안 .NET 8과 .NET 9는 한동안 지원이 계속 이루어질 수 있습니다. 그리고 .NET 10의 지원기간안에 .NET 11이 release 될 수 있습니다. 특별한 경우가 아니면 상위 .NET version은 하위 .NET version에 대한 호환성을 갖고 있으므로 만약 .NET 8이나 .NET 9로 개발된 Application이 있다면 Microsoft로부터의 지속적인 지원을 받을 수 있게 이를 현재 가장 최신 version의 .NET으로 전환할 것을 권장합니다. 그리고 이러한 전환방식은 향후 .NET 11이나 .NET 12가 발표되는 경우도 마찬가지입니다.

2) .NET의 지원체계와 관련된 용어

.NET의 생명주기는 사용되는 용어를 통해 그 지원 수준을 파악할 수 있습니다.

Release	Description
Preview	Preview라는 말이 붙으면 공식적으로 지원되지 않는 version으로 이해해야 합니다. 따라서 실제 Product수준의 Application개발대신 TEST나 사전 검토용으로만 사용되어야 합니다.
Go Live	GA동안에만 지원되는 것으로 그 이후에는 미지원상태로 전환됩니다. 따라서 가능한한 최신의 version으로 update해야 합니다. 보통 Release Candidate가 GA에 해당합니다.
Active	현재 .NET 10이 2025년 11월에서 2028년 5월까지 Active상태에 해당합니다. 이 기간동안 매달 bug와 보안관련 수정을 포함한 release가 이루어지므로 그에 맞춰 update를 유지해야 합니다.
Maintenance	생명주기의 마지막 6개월동안의 기간을 말하는 것으로 이때는 오로지 보안관련 수정만 이루어집니다. 본래 .NET 10의 지원기간은 2028년 11월까지인데 이 중 마지막 6개월을 제외한 기간만 Active로 잡히는 이유입니다. 또한 .NET 8과 .NET 9역시 조만간 maintenance상태로 진입할 것이므로 관련 Application Project가 존재한다면 이 기간동안 최신의 .NET Version으로 전환해야 합니다.
EOL	End of life로 지원이 더이상 이루어지지 않는 시기입니다. .NET 10은 2028년 11월이 넘어가게 되면 EOL에 도달하게 됩니다.

(1) EOL

End of life 또는 End of support라고 하는 EOL은 bug나 보안 patch, 기술지원등이 Microsoft에서 더 이상 지원되지 않는 것을 말합니다. .NET 10이 2025년 11월에 발표되면서 .NET 8을 제외한 이하 모든 .NET은 EOL에 도달하게 됩니다.

.NET 8	2025년 11월 기준 Active 상태이며 2026년 5월 maintenance상태로, 2026년 11월에 EOL에 도달하게 됩니다.
.NET 9	2025년 11월 기준 Active 상태이며 2026년 5월 maintenance상태로, 2026년 11월에 EOL에 도달하게 됩니다.
.NET 10	2028년 5월까지 Active 상태가 되며 그 다음 2028년 11월 EOL까지 maintenance상태에 있게 됩니다.
.NET 11	2026년 2월부터 2026년 11월까지 preview 상태에 있다가 그 다음부터 Active상태로 전환됩니다. 그리고 2028년 11월 EOL에 도달합니다.

모든 .NET version의 현재 상태와 EOL도달시기는 아래 link를 통해 더 자세히 확인할 수 있습니다.
https://github.com/dotnet/core/blob/main/releases.md

.NET 8과 .NET 9의 경우에는 2026년 11월 EOL에 도달하게 되는데 해당 version을 사용하는 project자체는 계속 운영할 수 있지만 보안 update가 더 이상 제공되지 않고 기술지원도 불가능하므로 신속히 새로운 .NET version으로 전환해야 합니다.

3) .NET Runtime과 SDK

Application을 standalone으로 build 하지 않는 한 .NET Runtime은 .NET Application을 실행하기 위해 필수로 OS에 설치되어 있어야 하는 최소한의 요구사항에 해당합니다. 반면 .NET SDK는 .NET Runtime과 함께 .NET Application을 build하기 위해 필요한 compiler 및 기타 다른 도구를 포함하고 있는 것입니다.

.NET Rumtime의 versioning은 semantic versioning의 규칙을 따르고 있어서 어떠한 대규모 변화의 발생 시 주 version이 증가하며 새로운 기능 및 기타 bug 수정의 경우에는 하위 version이 증가하게 됩니다. 하지만 .NET SDK의 versioning은 semantic versioning의 규칙을 따르고 있지 않으며 주와 부 version은 항상 .NET Runtime과 동일하게 유지됩니다. 다만 그 하위에 존재하는 부수적인 version번호만 SDK의 patch에 따른 증가값을 표시하고 있는데, 해당 version번호는 초기에 100부터 시작해서 첫 번째 숫자는 새로운 기능에 대한 변화를, 나머지 2개의 숫자는 bug나 보안 patch와 같은 변화를 나타냅니다.

	.NET Runtime	.NET SDK
초기상태	10.0.0	10.0.100
SDK Bug 수정	10.0.0	10.0.101
Runtime Bug 수정	10.0.1	10.0.101
SDK 기눙 수정	10.0.1	10.0.200

4) .NET 설치 관리

.NET Runtime의 경우 주 version에 대해서는 하위 version과 무관하게 호환성을 유지합니다. 예를 들어 .NET 10.0.0을 대상으로 개발된 project라 하더라도 향후 10.0.1이나 10.0.2와 같은 version이 나오는 경우 별다른 문제없이 무난하게 version을 update할 수 있습니다. 물론 단순 version상의 문제뿐 아니라 지속적인 관리를 위해서라도 꾸준히 update를 유지해야 할 필요가 있습니다.

.NET SDK의 경우도 마찬가지인데 초기 이전 version의 .NET SDK로 build한 project라 하더라도 향후 bug수정된 version의 SDK를 사용해 이전 project를 여전히 build할 수 있으며 심지어 주 version이 update된 11.0.100과 같은 경우에도 대부분의 경우 무리없이 판올림을 진행하여 build를 수행할 수 있습니다.

이러한 하위 호환성유지는 새로운 version의 .NET SDK가 설치된 경우라면 이전 version의 .NET SDK는 안전하게 삭제할 수 있다는 의미가 됩니다. 새로운 .NET SDK를 통해서도 이전 version의 모든 project를 build 할 수 있기 때문입니다.

현재 설치된 .NET SDK와 runtime을 보려면 아래 명령을 사용합니다.

dotnet --info

만약 SDK만 확인하려면 아래 명령을 사용하고

dotnet --list-sdks

Runtime이라면 아래 명령을 사용합니다.

dotnet --list-runtimes

만약 특정 SDK를 삭제하려 한다면 Windows 제어판의 'Programs and Features'에서 삭제할 수 있습니다.

5) .NET과 C#

.NET은 개발 Platform이고 C#은 개발언어에 해당합니다. 또한 C#은 .NET을 위한, .NET만을 위한언어로서 .NET과 아주 밀접하게 연결되어 있다 말할 수 있습니다.

C#언어가 Application으로 실행되는 과정을 보면 우선 C# code를 C# Compiler가 CIL(Common Intermediate Language) 혹은 IL Code라고 하는 형태로 compile 합니다. 그 다음 .NET Runtime의 구성요소 중 하나인 CLR(Common Language Runtime)에서 해당 IL Code를 load 한 뒤 이를 다시 JIT(Just In Time) Compiler가 실제 동작중인 Machine의 OS와 CPU가 이해할 수 있는 기계어 code로 변환하여 code를 실행하게 됩니다.

.NET세계에서 많이 쓰이는 VB.NET이나 F#도 마찬가지로 각각의 언어에 맞는 compiler를 가지고 있고 이들도 compile 하게 되면 공통적으로 IL Code가 만들어지는데 그다음 실행까지의 과정은 어떤 언어든지 모두 동일한 순서와 방식으로 처리됩니다.

C#은 언어일 뿐이므로 실제 C#없는 .NET Project는 존재할 수 있지만 .NET아닌 C#은 존재할 수 없습니다. 이론적으로 현재 C#은 개방형 표준이기 때문에 누구나 다른 platform을 위한 C# Compiler를 만들 수 있지만 실제 그렇게 만들어진 사례는 아직 존재하지 않으며 사실 그렇게 해야 할 이유도 없습니다.

엄밀하 말하면 .NET세계에서 C#을 꼭 사용해야 하는 것은 아닙니다. 이미 언급했듯이 C#, F#, VB.NET은 Programming언어에 물과 하며 Microsoft 역시 이들 언어 모두를 지속적으로 지원하고 있습니다. 다만 C#은 이 중에서 가장 우세한 지원쳬계에 속해 있으며 관련 자료 역시 방대하게 존재하므로 오히려 다른 언어를 사용하는 것보다 C#이 훨씬 접근성이 높다고 말할 수 있습니다.

(1) IL

상술했듯 .NET은 2번의 compiler과정을 거치고 있습니다. 이 중 첫 번째가 Roslyn이라고 하는 C# compiler에서 C# Source code를 compile 하여 IL로 변환한 뒤 이를 EXE나 DLL의 Assembly형태로 저장하는 것입니다. IL code는 Assembly언어와 비슷한 구조를 가지지만 오로지 CoreCLR이라고 하는 .NET Virtual Machine상에서만 실행될 수 있습니다. 두 번째 Compile은 Runtime때 실행되는데, CoreCLR이 Assembly에서 IL Code를 load 하면 JIT Compiler가 이를 현재 Machine의 OS와 CPU가 해석할 수 있는 구조의 기계어로 compile 하게 됩니다. 그리고 이렇게 두 번의 Compile과정을 거치고 나면 비로소 Code를 실행하게 됩니다.

두번의 Compile과정(C# -> IL -> Machine Code)은 언뜻 생각해 보면 불합리해 보일 수 있지만 동일한 IL Code를 가지고 Windows는 물론 Linux나 macOS든 어떠한 OS platform상에서도 실행시킬 수 있다는 아주 큰 장점을 제공해 줄 수 있습니다. Microsoft는 그저 각 OS에 맞는 CoreCLR을 만들어두기만 하면 되고, 해당 OS의 CoreCLR에서 두 번째 Compile과정을 거쳐 실행가능한 기계어로 변환될 수 있습니다.

C#뿐만 아니라 기타 다른 어떠한 언어든지 관계없이 첫 단계의 Compile에서 IL Code를 생성하게 되는데 중간언어라는 특성상 해당 Code의 구조를 역해석하면 본래 언어로 만들어진 Source code로 되돌려 보는 것이 가능합니다. 실제 이것을 가능하게 만드는 여러 가지 tool도 존재하는데 JetBranins사의 DotPeek나 Microsoft사의 ILSpy 등이 있습니다.

두 번째 Compile은 Runtime때에 이루어지는데 이러한 방식은 OS 간 높은 실행률을 보장할 수 있지만 단점은 역시 성능입니다. 한 번의 Compile로 곧장 실행가능한 형태의 file을 만들어내는 다른 언어의 Application과는 아무래도 비교될 수밖에 없습니다. Microsoft도 이러한 문제를 인식하고 있고 따라서 이에 대한 대안으로 AOT(Ahead of time) Compile을 제시하고 있습니다. AOT에 관해서는 추후에 다시 언급하도록 하겠습니다.

CoreCLR의 원래 이름은 CLR이지만 이는 .NET Framework때 Windows전용으로 사용되는 것으로 .NET이 Cross-platform인 Core시대로 접어들면서 CoreCLR로 명칭이 변경되었습니다. 전체 모든 CLR을 지칭하는 경우는 CLRs이라고 표현하기도 합니다.

.NET Core는 Cross-platform으로 처음 등장한때에 사용되던 용어로 현재는 .NET만 공식적인 명칭으로 사용되고 있습니다.

Runtime은 Application실행되는 시점을 의미합니다.

6) .NET과 .NET Framework

.NET Framework는 2002년부터 시작한 .NET Platform의 공식명칭이었으며 그 밖에 다른 관련 Platform이 등장하였지만 현재는 이 명칭이 .NET 이라는 것으로 통일되었습니다.

.NET Framework와 .NET은 명칭이 비슷하다 보니 이를 혼재해 사용하는 경우도 있는데 이 둘은 엄밀히 다르며 다음과 같은 특징으로 나누어 볼 수 있습니다.

.NET Framework	.NET Framework 4.8 / C# 8.0까지만 지원되는 것으로 향후 그 어떠한 지원계획도 존재하지 않습니다. 사실상 Windows전용의 Platform이며 오로지 기존 .NET Framework를 대상으로 한 Application을 유지관리하기 위한 목적으로만 사용해합니다. 따라서 신규 Project에 적용해서는 안됩니다.
.NET	C# 8.0부터 현재의 C# 14까지 지원하는 것으로 향후 유지관리동안에 신규 Project에 사용할 수 있는 Platform입니다. Windows뿐만 아니라 Linux, macOS, Android등 다양한 OS를 지원하며 기존의 .NET Framework Application을 최신 version인 .NET으로 전환하고자 하는 경우에도 사용할 수 있습니다.

지금까지 C#과 .NET에 대한 간단한 개념들을 살펴봤습니다. 이론적인 부분은 여기까지 하기로 하고 이제 예제를 통해 실제 Application을 만들기 위한 과정을 하나씩 짚어가도록 하겠습니다.

3. 예제 따라 하기

우선 VS2026을 사용해 Console Appp정도의 간단한 Application을 만들어 보는 것으로 시작할까 합니다. 하지만 만약 Windows OS를 사용하지 않거나 VSCode만을 사용하기로 결정했다면 사실 이 과정은 건너뛰어도 괜찮습니다. 사실 앞으로의 예제는 대부분 VSCode를 사용하는 경우가 많을 테지만 기본적인 개념은 거의 동일하므로 VS2026에 대한 설명을 지나친다고 하더라도 크게 문제가 될 건 없습니다.

1) VS2026을 사용해 .NET Project 만들기

기본적인 예제를 빠르게 만들어 보는 것을 목표로 하므로 일부 세부적인 설명은 생략할 수 있습니다. 그러나 생략된 설명은 추후에 자세히 설명될 것이므로 일단 설명대로 따라해 .NET Project를 생성해 보시기 바랍니다.

VS2026을 실행한 후 첫 화면에서 왼쪽에 'Create a new project'를 선택합니다.

'All languages'에서 C#을 선택하고 'Search for templates'에서 'console'을 입력합니다.

하단 template목록에서 가장 처음항목인 'Console App'을 선택하고 'Next'를 Click 합니다.

Project name에서 임의의 Project명을 입력하고 해당 Soluction(Project)가 저장될 경로를 Location에서 지정한 뒤 'Next'를 Click합니다.(저장위치와 Project명, Solution명은 자유롭게 설명할 수 있습니다. 예제에서는 기본값 그대로 사용하였습니다.)

Framework에서 '.NET 10 (Long Term Support)'를 설정합니다. 아마 대부분 기본적으로 선택가능한 '.NET 10'항목 하나만 존재할 테지만 만약 다른 version의 .NET SDK가 설치되어 있다면 .NET 9.0과 같이 다른 선택가능한 항목이 존재할 수 있습니다. 여기서 Enable container support, Do not use top-level statements 등 다른 설정은 그대로 남겨두고 'Create'를 Click한뒤 잠시 기다리면 다음과 같은 화면을 볼 수 있습니다.

처음 표시되는 code는 Program.cs file의 code로서 현재는 주석문 한 줄과 code 한 줄만이 존재하고 있습니다. Project생성 시 다른 option사항을 선택하지 않았다면 C# 9.0에서 도입된 top-level program기능을 사용하게 되므로 아주 간소화된 code만이 존재함을 알 수 있습니다.

이제 Code를 아래와 같이 간단히 수정해 봅니다.

// See https://aka.ms/new-console-template for more information
Console.WriteLine("안녕, C#");

(1) 예제를 Compile 하고 실행하기

상기와 같이 수정한 뒤 예제를 실행하기 위해 VS2026의 상단 Menu에서 Debug -> Start Without Debugging을 선택합니다. 그런 뒤 잠시 기다리면 다음과 같은 Console화면이 열리면서 예제가 실행될 것입니다.

Console화면의 색상이나 형태는 각 PC의 설정에 따라 조금씩 다르게 표시될 수 있습니다.

위 상태에서 임의의 key를 누르면 Console화면이 닫히고 VS2026 화면으로 되돌아갈 것입니다.

Solution Explorer에서 Project(예제에서는 ConsoleApp1)를 double click 하거나 Mouse오른쪽 button을 눌러 'Edit Project File'을 선택하면 아래와 같이 Project file(*csproj)의 내용이 표시될 것입니다. 아래 설정에 따라 현재 예제 Project는 .NET 10을 target으로 하고 있음을 알 수 있습니다.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

대게 Project file의 명칭은 Project명을 따라가므로 예제와 같은 경우라면 Project file명은 'ConsoleApp1.csproj'가 될 것입니다.

(2) Visual Studio에서 Debugger사용하기

VS2026에서 Project를 실행하는 경우 상황에 따라 Debugger를 사용할지 여부를 선택할 수 있습니다. 만약 debugging이 필요하지 않은 경우라면 Debugger를 사용하지 않는 편이 훨씬 더 나을 것입니다. 왜냐하면 Debugger를 사용하게 되면 더 많은 Resource를 사용하면서 속도도 Debugger를 사용하지 않는 것보다 더 느리게 실행될 것이기 때문입니다.

또한 Debugger를 사용하게 되면 단 하나의 Project만 실행할 수 있다는 단점도 존재합니다. 만약 하나이상의 Project를 Debugger를 사용하면서 동시에 실행해야 한다면 그만큼 VS2026을 중복으로 실행해 각각의 Project를 개별적으로 실행해야 합니다.

그런데 현재 Project에서 Debugger사용하도록 Project를 실행하면 Console화면이 표시되었다가 결과를 확인하기도 전에 금방 닫혀버리는 경우가 있습니다. 이런 경우 VS2026의 Tools -> Options -> Debugging -> General Menu를 선택하고 오른쪽 설정항목에서 'Automatically close the console when debugging stops'부분이 설정되어 있는지 확인합니다. 만약 이 설정이 설정상태에 있다면 Check표시를 지워 설정을 해제하도록 합니다.

(3) VS2026에서 Solution에 Project추가하기

대다수 Project는 단일 Solution에 단일 Project만이 존재하는 경우가 거의 없습니다. 필요에 따라 또는 용도에 따라 여러 가지 Project로 나뉘는 경우가 많이 때문에 Solution에 Project가 추가되는 경우는 흔하다고 할 수 있습니다.

VS2026에서 Solution에 Project를 추가하기 위해 File -> Add -> New Project...를 선택합니다.

비슷한 Menu로 File -> New -> Project/Solution이 있으나 이 기능은 새로운 Project와 Solution을 추가하는 것입니다.

Add a new project 화면에서 Recent project templates밑에 Console App을 선택하고 Next를 눌러줍니다.

Configure your new project 화면에서는 사용할 Project이름과 Project가 생성될 위치를 지정합니다. (예제에서는 기본값 그대로 사용하였습니다.)

Additional information 화면에서는 현재 표시된 상태 그대로 사용하되 'Do net use top-level statements'만 check 해 줍니다.

이제 Create를 눌러 Project를 생성합니다.

새로운 Project의 Program.cs를 열어보면 이번에는 아래와 같이 Project명과 동일한 Namespace가 선언되었고 Program internal class 및 내부에 args 매개변수를 가진 정적 Main method가 포함되어 있는 걸 확인할 수 있습니다.

namespace ConsoleApp2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}

위 상태에서 Project의 Namespace를 확인할 수 있도록 이전과 동일한 구문을 아래와 같이 추가해 줍니다.

static void Main(string[] args)
{
    string namespaceName = typeof(Program).Namespace ?? "이름없음";
    Console.WriteLine(namespaceName);
    Console.WriteLine("Hello, World!");
}

VS2026의 Solution Explorer에서 ConsoleApp1 Solution을 선택한 뒤 mouse오른쪽 button을 눌러 'Configure Startup Projects...'항목을 선택합니다.

그리고 'Solution 'ConsoleApp1' Property Pages화면에서 Startup Project를 Current selection으로 변경한 뒤 OK를 눌러 설정을 반영합니다.

그런 뒤 다시 Solution Explorer에서 ConsoleApp2 project를 선택(또는 Project내부에서 임의의 folder나 file을 선택해도 동일)하면 해당 Project명이 진하게 변경됨으로써 시작 Project로 설정되었음을 확인할 수 있습니다.

Solution Explorer에서 시작 Project로 바꾸고자 하는 Project명을 Mouse오른쪽 button으로 눌러 'Set as Startup Project'항목을 선택해도 동일한 기능을 수행할 수 있습니다.

이 상태에서 Project를 실행하면 다음과 같은 결과를 표시할 것입니다.

Visual Studio에서 Project를 실행하는 경우 해당 Application은 [Project명]\bin\Debug\net10.0 folder에 존재하는 Project file을 실행하게 됩니다. 하지만 VSCode(dotnet CLI)에서 Project를 실행하는 경우에는 VS20265과 다른 동작을 취하게 되므로 주의해야 합니다.

Solution을 생성한 뒤 Solution file확장자를 보면 기존의 sln에서 slnx로 변경되어 있음을 알 수 있습니다. sln은 해당 Solution만의 고유한 방식으로 장황하며 읽기 어려운 구조로 되어 있고 GUID(Globally Unique Identifiers)를 사용해 Solution에 포함된 다른 Project나 Component를 참조하고 있습니다. 하지만 slnx는 XML을 사용하는 방식으로 간단하면서도 상대적으로 읽기 쉬운 구조를 갖고 있습니다. 아마도 VS2026에서는 slnx가 기본 Solution file로 설정되어 있을 테지만 그렇지 않거나 다른 file을 기본 Solution file로 설정해야 한다면 Tools -> Options -> Projects and Solutions의 설정화면에서 General부분의 설정을 바꿔줄 수 있습니다.

2) bin과 obj folder

bin과 obj는 compiler에 의해 자동으로 생성되는 folder로서 obj는 각 source file을 compile 한 하나의 object file을 포함하고 있으며 bin은 App이나 class library로서 실행가능한 binary file을 포함하고 있는 folder입니다.

물론 해당 folder의 구조나 내부에 포함하고 있는 file들을 세부적으로 모두 알아야 할 필요는 없지만 어쨌건 상기 2개의 folder와 file은 Compiler가 Project를 build 할 때마다 임시적으로 생성한다는 점을 기억하시기 바랍니다. 원한다면 이들 folder를 삭제할 수 있지만 Project를 build 하는 과정을 거칠 때마다 folder는 다시 생성됩니다. 대개의 경우 bin과 obj를 가지고 뭔가를 해야 하는 경우는 거의 없기 때문에 현재는 이런 것이 있다는 정도만 알고 넘어가면 충분합니다.

위 folder안에 여러 file 중 '.g.'와 같이 중간에 g가 붙은 file을 볼 수 있는데 여기서 'g'는 generated를 의미합니다. 해당 파일은 build과정에서 새롭게 만들어지므로 file을 삭제하거나 file명을 변경하는 것은 무의미하며 그렇게 해야 할 이유도 없습니다.

bin과 obj는 수동적으로 삭제할 수 있지만 VS2026의 'Solution Explorer'에서 'clean'을 통해 삭제할 수도 있습니다. 이렇게 하려면 Project를 mouse오른쪽 button으로 눌러 'Clean'항목을 선택하기만 하면 됩니다. 이러한 동작은 dotnet CLI에서 'dotnet clean'명령한 것과 동일합니다.

3) Top-level Programs

예전에 .NET Project를 신규로 생성하는 경우 처음 시작되는 code는 다소 장황한 느낌이 있었습니다. 심지어 비교적 단순한 Console App을 생성하는 경우에도 한줄짜리 간단한 message를 출력하는것이 전부인데 간단한 동작과는 다르게 몇줄짜리 code가 기본으로 생성되곤 했습니다. 하지만 이러한 방식은 .NET 6이후부터 compiler가 필수적인 code를 대신 처리해 줌으로서 기본으로 시작되는 code의 양이 크게 간소화되기 시작했습니다.

.NET 5 또는 그전에서나 혹은 그 이후의 .NET Version이라 하더라도 Project생성 시 'Do net use top-level statements'항목을 선택했다면 Program.cs는 다음과 같은 형태로 만들어지게 됩니다.

using System;

namespace ConsoleApp1
{
    class Program
    {
        staic void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}

하지만 .NET 6부터 Program class와 Main method는 compiler에 의해 자동으로 생성되어 개발자가 작성한 code를 감싸는 형태로 처리하게 되므로 주석과 code구문을 포함한 단 2줄만 Program.cs에 표시하게 되었습니다.

사실 top-level programs라는 기능은 .NET 5부터 도입된 것인데 이걸 Microsoft는 .NET 6에 와서야 Console App project의 template에 기본으로 적용하도록 하였으며 .NET 7부터 개발자의 선호도에 따라 직접 어떤 style로 시작할지 선택할 수 있도록 하였습니다. 따라서 top-level programs기능을 사용하고 싶지 않다면 VS2026의 경우 Project생성 시 'Do net use top-level statements'를 선택하면 되고 dotnet CLI를 사용하는 경우 '--use-program-main'이라는 option을 붙여주면 됩니다.

일반적인 경우라면 namespace는 project명과 동일하게 생성되지만 top-level programs기능을 사용하는 경우 namespace가 정의되지 않으므로 Program class는 암시적으로 이름이 없는 빈 namespace상에서 정의됩니다.

Top-level Programs은 compile과정에서 필연적으로 code가 수정되어야 하므로 다음 사항을 기억해야 합니다.

Project에서 단 하나의 파일에만 적용할 수 있습니다.
Namespace import를 위한 모든 using문은 file의 상단에 위치해야 합니다.
Class나 기타 다른 type을 선언하는 경우 file의 하단에 위치해야 합니다.
주 진입함수의 Method이름인 Main은 직접적으로 사용할 수 없습니다. Main함수를 명시적으로 정의하고자 하는 경우에도 compile과정에서 <Main>$로 변경됩니다.

4) Global Namespace Import

만약 System namespace를 import 하고자 한다면 우리는 해당 file 상단에 다음과 같이 구문을 작성할 수 있습니다.

using System;

위와 같이 구현하면 System namespace에 속해있는 Console을 바로 사용할 수 있고 따라서

Console.WriteLine...

위와 같은 구문작성이 가능하게 됩니다. 하지만 이전에 만든 예제의 경우 'using System;'문을 사용하지 않았음에도 불구하고 Console.WriteLine...구문을 그대로 사용되었음을 볼 수 있습니다. 이런 것이 가능한 이유는 Project가 C# 10/.NET 6에서 도입된 Global Namespace Import라는 기능을 사용하고 있기 때문입니다.

VS2026의 Solution Explorer에서 obj -> Debug -> net10.0 folder를 순서대로 열어보면 '[Project명].globalUsings.g.cs'라는 file을 볼 수 있습니다.(예제에서는 'ConsoleApp1.GlobalUsings.g.cs') 이 file은 .NET 6부터 compiler에 의해 자동으로 생성되는 file로 Global Namespace Import의 기능을 수행하는 file입니다. 해당 file을 열어보면 다음과 같이 구현되어 있는데

// <auto-generated/>
global using System;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;
global using Systehttp://m.Net.Http;
global using System.Threading;
global using Systehttp://m.Threading.Tasks;

System과 같이 어느 Project에서나 적용되는 공통적인 일부 Namespace가 Impport 되어 있음을 알 수 있습니다. 이러한 구현은 Project내의 모든 code file에 적용되는 것으로 이 기능덕에 각 code file에서는 저마다 공통적으로 import 하는 반복적인 작업을 생략할 수 있게 되었습니다. 이 기능에 관한 더 자세한 사항은 추후에 다시 다룰 것입니다.

5) 예외를 통해 자동으로 생성된 Code 살펴보기

Top-level Programs기능은 본래 필요한 Code를 생략하는 것이 아니라 Compile과정에서 생성해 주는 방식으로 동작합니다. 다시 말해 Compile을 거쳐지 않으면 볼 수 없다는 얘기인데 대신 Runtime에서 예외를 일으키게 되면 숨겨진 Code를 확인할 수 있습니다.

Project의 Program.cs에서 다음과 같이 예외를 일으키는 구문을 추가합니다.

// See https://aka.ms/new-console-template for more information
Console.WriteLine("안녕, C#");
throw new Exception();

그리고 VS2026의 Debug -> Start Without Debugging를 선택해 Project를 실행합니다. 이때 Debugging으로 Project를 시작하지 않도록 주의해야 합니다. 예외가 발생하면 Debugger에 의해 예외가 다뤄지기 때문에 보려고 하는 결과를 제대로 살펴볼 수 없습니다.

Project가 실행되면 다음과 같은 결과를 표시할 것입니다.

결과를 보면 인수의 전달을 위해 args라는 매개변수를 사용하고 있는 <Main>$이름의 Main method를 볼 수 있으며 해당 Mehtod는 Program Class안에 정의되었음을 알 수 있습니다. 이러한 부분은 Compiler에 의해 자동으로 생성된 것입니다.

6) Program class의 Namespace확인하기

이전에 top-level program에서의 Namespace는 이름이 없다고 언급한 적이 있는데 그것이 사실인지 확인해 보겠습니다.

Program.cs에서 예외처리한 구문 위에 아래의 구문을 추가합니다. 해당 구문은 Program class의 Namespace이름을 가져와 이를 화면에 표시하도록 합니다.

using System.Text;

Console.OutputEncoding = Encoding.UTF8;
Console.InputEncoding = Encoding.UTF8;

Console.WriteLine("안녕, C#");

string namespaceName = typeof(Program).Namespace ?? "이름없음";
Console.WriteLine(namespaceName);

throw new Exception();

예제에서 사용된 ??은 null 조건부 연산자로서 왼쪽 피연산자가 null인 경우 반환값을 오른쪽 값으로 대체하도록 하는 연산자입니다.

VS2026의 Code Editor는 code snippets라는 기능이 있어 일반적으로 사용되는 긴 문장을 짧은 글로 대체하여 입력할 수 있습니다. 예를 들어 'Console.WriteLine()'을 입력하고자 하는 경우 cw를 입력한 뒤 Tab이나 Enter key를 누르게 되면 자동으로 'Console.WriteLine()'가 입력된 뒤 괄호 안에 Cursor를 이동시켜 곧바로 화면에 표시하고자 하는 내용을 입력할 수 있는 상태가 됩니다. 좀 더 자세한 사항은 아래 link를 참고하시기 바랍니다.
https://learn.microsoft.com/en-us/visualstudio/ide/code-snippets?view=visualstudio

예제에서 사용된 Console.OutputEncoding과 Console.InputEncoding은 Console에 한글이 표시될 때 글자가 깨지는 현상을 방지하기 위해서 추가한 것입니다.

예제를 실행하면 아래와 같은 결과를 표시할 것입니다.

7) C# Code를 Project file 없이 실행하기

VS2026에서 Project를 생성하고 실행해 본 지금까지 예와 같이 C# Code file(.cs)은 물론 기타 여러 가지 file들이 하나의 Project안에 포함되어 있고 이를 관리하는 Project file이 필수적으로 필요하다는 것을 알 수 있습니다. 이런 Project file은 내부에서 target이 되는 .NET Runtime Version이나 nullability언어기능, global namespace import와 같은 어려가지 설정들을 포함하고 있으며 다른 Project나 Package의 참조정보를 가지고 있기도 합니다.

그런데 예제처럼 복잡하지 않은 아주 단순한 Console App만을 필요로 한다면, 게다가 기본적으로 적용되는 Project규칙의 대부분을 굳이 따로 설정하거나 바꿀필요가 없다면 Project단위의 관리는 오히려 Application을 만드는데 복잡한 절차만 더해지는 꼴이 될 수 있습니다.

다른 언어, 예를 들면 Python과 같은 언어의 경우 Project단위가 아니라 하더라도 아래와 같이 단일 file에 대한 실행방식을 지원하고 있습니다.

python app.py

(1) File-based apps

Microsoft는 이러한 문제를 해결하고자 C# 14에서 file-based apps라는 기능을 도입하게 되었습니다. 이 기능은 python과 비슷하게 단일 cs file로만 직접적으로 실행가능하도록 합니다.

dotnet run mycsapp.cs

단일 file로 Application을 만드는 경우에도 top-level 구문을 사용할 수 있기 때문에 Namespace와 Main을 따로 정의해야 하는 번거로움이 없으며 복잡한 Project구조를 따르지 않기 때문에 Application을 더욱 간단하고 빠르게 만들어낼 수 있습니다. 특히 C# 언어에 대한 학습이나 간단한 TEST가 필요할 때 손쉽게 사용가능한 유용한 방식이라 할 수 있습니다.

File-based apps기능을 사용할 때 file명은 굳이 Program.cs일 필요가 없습니다.

(2) File-based apps 만들기

우선 알아둬야 할 건 File-based app은 dotnet CLI 기능이므로 VS2026에서 만들 수 없다는 것입니다. 따라서 적당한 folder를 하나 만들고 여기서 VSCode와 같은 Code편집기로 임의의 cs file을 하나 생성한 뒤 필요한 file내용을 직접 작성합니다. 예제에서는 FileBasedApps folder에 test.cs라는 file을 만들어보았습니다.

File을 저장한 뒤 Windows Terminal이나 VSCode의 Terminal에서 FileBasedApps folder로 위치한 뒤 아래와 같은 명령을 사용해 file을 실행합니다.

dotnet run test.cs

잠시 기다리면 다음과 같은 결과를 표시할 것입니다.

현재까지 File-based apps는 하나의 file만을 지원합니다. 다수의 file에 대한 지원은 .NET 11에서 지원될 예정입니다.

(3) File-based apps에 대한 추가지원 기능

Project 없는 단일 cs file이라고 하더라도 외적인 기능을 지원해야 하는 경우가 있을 수 있습니다. 이럴 때는 특별한 지시자문자인 '#:'을 사용합니다.

예를 들어 특정 NuGet Package를 필요로 하는 경우 아래와 같이 NuGet참조를 추가할 수 있습니다.

#:package Newtonsoft.Json@13.0.3

using Newtonsoft.Json;

var obj = new { Name = "홍길동", Age = 30 };
string json = JsonConvert.SerializeObject(obj);
Console.WriteLine(json);

만약 외부의 Class Library를 참조해야 한다면 아래와 같이 사용할 수 있고

#:project ../MyLibrary/MyLibrary.csproj

특정 SDK를 지정해야 한다면 #:sdk를 사용하면 됩니다.

#:sdk Microsoft.NET.Sdk.Web

using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;

Console.WriteLine("ASP.NET Core SDK 로드 완료!");

SDK의 Version을 구분해야 한다면 @를 사용합니다. (#:sdk Microsoft.NET.Sdk.Web@11.1.0)

또한 MS Build 속성의 설정도 가능해서 C#언어의 Version을 다음과 같이 지정할 수도 있습니다.

#:property LangVersion=9.0

위와 같이 만들어진 cs file은 추후 필요하다면 아래 명령을 통해 완벽한 Project형태로 재생성할 수 있습니다.

dotnet project convert test.cs

배포가 필요하다면 그것 역시 가능한데

dotnet publish test.cs

다만 위와 같이 하는 경우 기본적으로 AOT Compile이 적용되므로 이를 끄고자 한다면 #:property를 통해 다음과 같이 설정해야 합니다.

#:property PublishAot=false

File-based apps에 관한 더 자세한 사항은 아래 link를 참고해 보시기 바랍니다.
https://devblogs.microsoft.com/dotnet/announcing-dotnet-run-app/

Announcing dotnet run app.cs - A simpler way to start with C# and .NET 10 - .NET Blog

Run C# files instantly with dotnet run app.cs, no project file needed! Coming to .NET 10, try it out today in Preview 4.

devblogs.microsoft.com

관련하여 동영상도 시청할 수 있습니다.
https://www.youtube.com/watch?v=98MizuB7i-w

감사합니다.

Hyper-V Virtual Machine상에서 Docker실행하기

클리엘 — Sat, 4 May 2024 16:53:25 +0900

일단 Virtual Machine상에서 Docker를 설치할 때 설치 option에서 Hyper-V대신 WSL(Windows Subsystem Linux)을 사용한다는 설정이 있습니다. 이 설정을 제외하고 설치합니다.

그런 뒤 Docker를 실행하면 다음과 같은 오류를 볼 수 있는데

말이 길지만 내용은 BIOS상에서 가상화를 설정해야 한다는 것입니다. 하지만 Hyper-V의 Virtual Machine에서 BIOS를 제한적일 수밖에 없습니다. 이 문제를 해결하려면 Virtual Machine를 끈뒤 Host Machine상에서 관리자 권한으로 PowerShell를 실행하고 아래 명령을 통해 Virtual Machine의 가상화를 설정해 줘야 합니다.

Set-VMProcessor -VMName Windows11 -ExposeVirtualizationExtensions $true

위 명령에서 Windows11은 Virtual Machine의 이름입니다. Virtual Machine의 이름에 'Windows 11'처럼 공백이 있으면 오류가 날 수 있으므로 공백을 없애주는 것이 좋습니다.

[C# 12와 .NET 8] 11. LINQ

클리엘 — Mon, 11 Mar 2024 12:04:55 +0900

LINQ(Language INtegrated Query)는 일련의 data를 대상으로 filtering 및 sorting 하고 다른 형태로 결과를 투영할 수 있는 언어확장 도구입니다.

1. 왜 LINQ인가?

(1) 명령형및 선언형 언어의 비교

LINQ는 2008년 .NET 3.0과 .NET Framework 3.0과 함께 도입되었습니다. 그전에 C#및 .NET개발자는 명령형이라고 하는 절차적 code문을 사용해 예를 들어 loop처럼 일련의 item들을 처리하곤 했습니다.

첫 번째 item에 대한 현재 위치를 설정합니다.
지정한 값과 하나 또는 그 이상의 속성을 비교 비교하여 예를 들어 가격이 50 이상이어야 한다거나 수량이 동일한지등과 같은 경우처럼 처리해야 하는 item인지를 확인합니다.
2번에서 조건과 일치하는 경우라면 item을 처리합니다. 예를 들어 사용자에게 하나 또는 그 이상의 속성을 표시하거나 새로운 값으로 update 할 수 있고 또는 item을 제거하거나 counting과 summing처럼 값을 집계할 수도 있을 것입니다.
다음 item으로 이동합니다. 모든 item이 처리될때까지 이 과정을 반복합니다.

명령형이라고 하는 절차적 code는 compiler에게 '이렇게 하라. 저렇게 하라'와 같이 주어진 목표를 어떻게 달성할 수 있는지를 말해줍니다. Compiler는 우리가 달성하고자 하는 목표자체를 알 수 없기 때문에 그 자체로 우리를 도울 수는 없습니다. 모든 방법적 절차가 정확하게 맞다는 것에 대한 모든 책임은 100% 개발자가에게 있습니다.

LINQ는 이러한 일반적인 작업들을 오류를 최소화하면서 더 쉽게 code를 만들 수 있도록 해줍니다. Move나 read, update 기타 등등 각각의 동작에 대한 상태를 명시적으로 설명하는 대신 LINQ는 개발자가 선언적 혹은 기능적인 style의 문을 작성할 수 있도록 합니다.

선언적 code는 compiler에게 달성하기 위한 목표가 무엇인지를 말해주며 compiler는 가장 최적의 방법을 통해 목표를 달성하게 됩니다. 또한 해당 문은 기존보다 더 간소하면서도 깔끔한 상태를 유지할 수 있습니다.

LINQ를 제대로 이해하지 않으면 작성한 code는 약간의 자체적인 bug를 갖게 될 수 있습니다. 아래 글을 읽어보세요.(https://twitter.com/amantinband/status/1559187912218099714). 해당 부분과 관련해서 솔직히 말하자면 이것은 LINQ의 동작과 multi-threading 동작이 결합된 것으로 사람들이 가장 혼란스러워 하는 것이 이 부분이므로 code가 위험해 질 수 있는 부분을 잘 이해해야 합니다.

2. LINQ 표현식

이전 글을 통해 우리는 이미 간단하게나마 LINQ를 사용해 본적이 있습니다.

그러나 위의 글에 대한 핵심은 LINQ가 아니므로 LINQ가 어떻게 동작하는지에 대해서는 생략했습니다. 이제 LINQ의 표현식을 이해하기 위한 시간을 가져보고자 합니다.

(1) 무엇이 LINQ를 만드는가?

LINQ는 몇가지 부분으로 나뉠 수 있는데 일부는 필수적이지만 일부는 선택적입니다.

Extension method(필수적) : 여기에는 Where나 OrderBy 그리고 Select를 포함한 LINQ의 기능을 제공합니다.
LINQ provider(필수적) : 여기에는 memory상에서 개체를 표현하기 위한 LINQ to Objects와 외부 database에 저장된 data와 EF Core를 통한 model을 처리하기 위한 LINQ to Entities, 그리고 XML로 저장된 data를 처리하기 위한 LINQ to XML을 포함합니다. 이들 provider는 다양한 유형의 data에 대해 특정한 방식으로 LINQ표현식을 실행합니다.
Lambda 표현식(선택적) : LINQ query를 간소화하기 위해 명명된 method대신 예를 들어 filtering를 위한 Where method를 조건부 논리와 같이 사용할 수 있습니다.
LINQ query comprehension 구문(선택적) : 여기에는 from, in, where, orderby, descending, select와 같은 C# keyword가 존재합니다. 이들은 몇몇 LINQ 표현 method에 대한 별칭에 해당하며 특히 이미 SQL(Structured Query Language)과 같이 다른 query언어를 경험해 본 적이 있다면 이들을 더욱 친숙하게 사용할 수 있을 것입니다. 처음 LINQ를 사용할 때는 종종 LINQ query comprehension 구문을 LINQ라고 오해하는 경우도 있는데 이것은 선택적으로 사용하는 LINQ의 여러 부분 중 하나에 해당할 뿐입니다.

(2) 열거 가능한 class에 LINQ 표현식 적용하기

Where나 Select와 같은 LINQ 확장 method는 Enumerable static class에 의해 IEnumerable<T>를 구현하는 모든 sequence type에 추가되었습니다.

예를 들어 모든 type의 array는 IEnumerable<T> class를 구현하며 여기서 T는 array에 속하는 item에 대한 type을 의미합니다. 다시 말해 모든 array는 질의와 이들의 조작하는데 대한 LINQ를 지원한다고 할 수 있습니다.

List<T>, Dictionary<TKey, TValue>, Stack<T>, Queue<T>와 같은 모든 generic collection은 IEnumerable<T>를 구현하므로 이들도 역시 LINQ를 통해 data질의하고 변경할 수 있습니다.

Enumerable은 아래 표에서 요약된것처럼 50여 개 이상의 method를 정의하고 있습니다.

아래 표는 향후 참고용으로 유용할 수 있지만 지금은 간단하게 어떤 method가 존재하고 나중에 어떤 method를 사용하는 것이 적절한지 확인하는 차원에서 살펴볼 수 있습니다.

Method	Description
First, FirstOrDefault, Last, LastOrDefault	Sequence에서 첫번째 혹은 마지막 item을 가져오며 예외 혹은 type에 대한 기본값을 반환할 수 있습니다. 예를 들어 첫번째 혹은 마지막 item이 존재하지 않는 경우 int type이면 0을 참조 type이라면 null을 반환합니다.
Where	지정한 filter와 일치하는 item에 대한 sequence를 반환합니다.
Single, SingleOrDefault	지정한 filter와 일치하는 item을 반환하거나 아니면 예외 혹은 일치하는 것이 존재하지 않는다면 type에 대한 기본값을 반환합니다.
ElementAt, ElementAtOrDefault	지정한 index위치의 item을 반환하거나 아니면 예외 혹은 position에 해당하는 item이 존재하지 않는 경우 type의 기본값을 반환합니다. .NET 6에서 도입된것은 int대신 Index를 전달할 수 있게 overload되어 Span<T> sequences에서 더 효휼적입니다.
Select, SelectMany	Item을 다른 type으로 투영하며 item의 중첩된 계층을 평탄화합니다.
OrderBy, OrderByDescending, ThenBy, ThenByDescending	지정된 field또는 속성을 통해 item을 정렬합니다.
Order, OrderDescending	.NET 7에 도입된 것으로 item을 item자체별로 정렬합니다.
Reverse	Item의 순서를 뒤집습니다.
GroupBy, GroupJoin, Join	두개의 sequences를 group화 하거나 join합니다.
Skip, SkipWhile	Item 특정 수만큼 skip하거나 표현식이 true일때까지 skip합니다.
Take, TakeWhile	Item을 특정 수만큼 가져오거나 표현식이 true일땨까지 가져옵니다. .NET 6에서 도입된 것은 Range를 전달할 수 있도록 overload되었는데 예를 들어 Take(range: 3..^5)은 3번째 item부터 시작하여 5번째 item에서 끝나는 부분집합을 가져온다는 것을 의미합니다. 또는 Skip(4)대신 Take(4..)와 같이 사용할 수도 있습니다.
Aggregate, Average, Count, LongCount, Max, Min, Sum	전체값 계산
TryGetNonEnumeratedCount	Count()는 Count속성이 sequence하에서 구현되었는지를 확인하고 그 값을 반환하거나 item을 count하기 위해 전체 sequence를 열거합니다. .NET 6에서 도입된 것은 해당 method로 오로지 Count만을 확인하여 없는 경우 잠재적인 저성능 운용을 동작을 방지하기 위해 false를 반환하며 out매개변수를 0으로 설정합니다.
All, Any, Contains	Item이 filter에 대해 전체 혹은 일부와 일치하거나 sequence가 지정한 item을 포함하고 있다면 true를 반환합니다.
Cast<T>	지정한 type으로 item을 형변환합니다. 이것은 비 generic개체를 generic type으로 변환할때 유용하게 사용될 수 있습니다.
Distinct	중복 item을 제거합니다.
DistinctBy, ExceptBy, IntersectBy, UnionBy, MinBy, MaxBy	Item의 전체가 아닌 일부만을 사용해 비교를 수행할 수 있습니다. 예를 들어 전체 Person개체를 비교함으로서 Distinct를 통해 중복 item을 제거하는 대신 LastName과 DateOfBirth만 비교함으로서 DistinctBy를 통해 중복 item을 제거할 수 있습니다.
Chunk	크기가 지정된 batch로 sequence를 분할합니다.
Append, Concat, Prepend	Sequence별 결합동작을 수행합니다.
Zip	Items의 위치를 기반으로 2개 혹은 3개의 sequence에 대한 일치 작업을 수행합니다. 예를 들어 첫번째 sequence에서 position이 1인 item은 두번째 sequence의 position 1인 item과 일치합니다.
ToArray, ToList, ToDictionary, ToHashSet, ToLookup	Sequence를 array나 collection으로 변환합니다. 이들은 지연된 실행을 기다라기 보다는 LINQ표현식의 즉각적인 실행을 강제하는 유일한 method입니다.

As와 To로 시작하는 확장 method의 차이에 대해 확실히 해둘 필요가 있습니다. As로 시작하는, 예를 들어 AsEnumerable method는 sequence를 다른 type으로 변환하기는 하지만 memory를 할당하지 않으므로 빠르게 동작합니다. 하지만 To로 시작하는, 예를 들어 ToList와 같은 method는 새로운 item의 sequence에 대한 memory를 할당하게 되므로 상대적으로 느릴 수 있으며 또한 더 많은 memory resource를 사용하게 됩니다.

Enumerable class는 또한 확장 method가 아닌 아래 표에서 설명한 바와 같이 다른 몇몇 method들도 가지고 있습니다.

Method	Description
Empty<T>	지정된 type T에 대한 빈 sequence를 반환합니다. 대게 IEnumerable<T>를 필요로 하는 method에서 빈 sequence를 전달할때 유용하게 사용될 수 있습니다.
Range	Count item을 통한 시작값으로 부터 정수 sequence를 반환합니다. 예를 들어 Enumerable.Range(start: 5, count: 3)는 정수 5, 6 그리고 7을 포함합니다.
Repeat	Count횟수만큼 반복되는 같은 요소를 포함하는 sequence를 반환합니다. 예를 들어 Enumerable.Repeat(element: "5", count: 3)은 문자열값 "5", "5", "5"를 포함합니다.

(3) 지연된 실행(deferred execution)

LINQ는 지연된 실행을 사용합니다. 이는 위에서 언급한 확장 method 대부분을 호출하면 query를 실행하지 않고 결과를 가져온다는 것을 이해하는데 중요한 부분이며 이때 이들 확장 method의 대부분은 답이 아닌 질문을 나타내는 LINQ 표현식을 반환합니다.

Visual Studio 2022에서 csStudy11 solution을 생성하고 여기에 LinqWithObjects이름의 console app project를 추가합니다.

이제 Program.cs에서 기존의 문을 모두 제거하고 아래와 같이 특정 인물에 대한 문자열값의 sequence를 정의합니다.

string[] names = new[] { "이순신", "이도", "신사임당", "홍길동", "김종서", "박혁거세", "김좌진", "윤봉길" };

// 질문 : 이름이 '이'자로 시작하는 사람은 누구인가?

//확장 method 사용
var query1 = names.Where(name => name.StartsWith("이"));

//LINQ query comprehension syntax 사용
var query2 = from name in names where name.StartsWith("이") select name;

질문에 대한 답을 얻으려면 즉, query를 실행하려면 다음과 같이 ToArray나 ToLookup과 같은 To method 중 하나를 호출하거나 query를 열거해야 합니다.

//질문의 답을 포함하는 문자열 arrary를 반환
string[] result1 = query1.ToArray();
//질문의 답을 포함하는 문자열의 list를 반환
List<string> result2 = query2.ToList();
//결과를 열거함으로서 질문의 답을 반환
foreach (string name in query1)
{
	Console.WriteLine(name);

	names[1] = "유관순"; //이도를 유관순으로 변경 -> 유관순은 '이'자로 시작하지 않는다.
}

위 예제를 실행하면 다음과 같은 결과를 표시하게 됩니다.

지연된 실행때문에 첫 번째 결과인 '이순신'을 출력한 이후 본래 배열의 값이 바뀌게 되면 loop로 다시 돌아갈 때쯤 '이도'가 '유관순'으로 변경되었으므로 더 이상 일치하는 것이 없게 되고 따라서 오로지 '이순신'만 표시되는 것입니다.

(4) Where를 통한 entity filtering

LINQ를 사용하는 가장 일반적인 이유는 Where확장 method를 사용해 sequence안에서 item을 filtering하기 위한 것입니다. 예제를 통해 sequence를 정의하고 여기에 LINQ동작을 적용함으로써 filtering을 사용해 보겠습니다.

우선 Project file(*.csproj)에서 아래와 같이 global로 자동으로 import 되는 System.Linq를 제거하기 위한 요소를 추가합니다.

<ItemGroup>
	<Using Remove="System.Linq" />
</ItemGroup>

그리고 Program.cs에서 names에 Where 확장 method를 호출하도록 합니다. 이때 Where를 입력하기 위해 typing울 시도하면 아래와 같이 IntelliSense에 의해 array에서 사용가능한 member들이 표시되는데

이상한 점은 여기에 표시되는 member들 중에서는 Where가 존재하지 않는다는 것입니다. 이는 Where가 확장 method이기 때문이며 array type에는 기본적으로 존재하지 않는 member이기 때문입니다. 따라서 Where 확장 method를 사용하려면 System.Linq namespace를 import 해야 합니다. .NET 6부터는 암시적으로 import 되는 것이 기본이지만 위에서 우리는 이미 System.Linq가 import 되지 않도록 Remove 했기 때문에 사용할 수 없게 되었습니다.

다시 Project file에서 위에서 추가한 System.Linq Remove요소를 삭제하고 names에서 Where method를 호출하도록 시도하면

IntelliSense는 Enumerable class에 의해 추가된 extension method를 추가한 member들을 표시할 것입니다. 또한 Where method에서 IntelliSense는 Where method를 호출하기 위해 Func<string, bool> delegate의 instance를 전달해야 함을 말해주고 있습니다.

Func<string, bool> delegate의 새로운 instance를 생성하기 위한 표현식을 입력합니다. 하지만 다음 단계에서 method의 이름을 정의할 것이기 때문에 아직까지는 method이름을 제공하지 않았습니다. (오류발생)

var query = names.Where(new Func<string, bool>());

Func<string, bool> delegate는 우리에게 각 string변수에 method로 전달되고 method는 반드시 bool값을 반환해야 함을 말해주고 있습니다. Method가 true를 반환한다면 이것은 결과에서 해당 string을 포함하고 있음을 의미하며 그렇지 않으면 포함하고 있지 않음을 의미합니다.

(5) 명명된 method 사용하기

Project에서 Function.cs 이름의 class file을 추가하고 여기에 partial Program class를 정의한 뒤 아래와 같이 3글자 이상의 이름만을 포함시킬 method를 정의합니다.

partial class Program
{
	static bool NameLongerThanFour(string name)
	{
		return name.Length > 3;
	}
}

그리고 Program.cs로 돌아와 위에서 정의했던 Func<string, bool> delegate로 method의 이름을 전달하고

var query = names.Where(new Func<string, bool>(NameLongerThanFour));

해당 query를 열거하도록 하면

foreach (var name in query)
{
	Console.WriteLine(name);
}

다음과 같은 결과를 표시할 것입니다.

(6) Delegate를 제거하여 code 간소화하기

사실 Func<string, bool> delegate의 instance는 명시적으로 제거할 수 있습니다. 그러면 code를 더욱 간소화할 수 있는데 이는 C# compiler가 편의상 delegate를 instance화 할 수 있기 때문입니다.

이전의 문을 복사한 뒤 그대로 주석처리하고 복사된 code를 다시 넣습니다. 그런 뒤 붙여 넣은 code에서 아래와 같이 method이름만 남겨두고 delegate의 instance를 제거합니다.

//var query = names.Where(new Func<string, bool>(NameLongerThanFour));
var query = names.Where(NameLongerThanFour);

예제를 실행하면 이전과 동일한 결과를 표시할 것입니다.

(7) Lambda 표현식 사용하기

예제의 code를 더 간소화할 수 있는 방법으로 명명된 method를 사용하는 대신 lambda expression을 사용할 수 있습니다.

비록 이러한 방법이 처음에는 복잡하고 어려워 보일 수 있으나 lambda expression은 이름이 없는 함수로서 => 기호(goes to라고 함)를 사용해 반환값을 표현할 수 있습니다.

위의 예제를 다시 복사하여 기존의 문을 주석처리한 뒤 복사한 code를 붙여 넣어 아래와 같이 변경합니다.

//var query = names.Where(new Func<string, bool>(NameLongerThanFour));
//var query = names.Where(NameLongerThanFour);
var query = names.Where(name => name.Length > 3);

예제를 보면 NameLongerThanFour method의 모든 중요한 부분이 lambda 식에 포함되어 있는 것을 알 수 있고 또 이것이 전부입니다. lambda 식은 크게 아래 2가지를 정의하고 있는데

입력 매개변수의 이름 : name
반환 값 표현식 : name.length > 3

여기서 name 입력 매개변수의 type은 sequence가 포함하고 있는 문자열값으로 추론되며 Where에서 가능한 delegate의 정의에 따라 반환값은 bool이 됩니다. 따라서 => 기호 이후 표현식에서는 반드시 bool값을 반환하도록 해야 합니다.

Compiler는 우리를 위해 대부분의 작업을 수행하므로 code는 가능한 한 간소화할 수 있습니다. 예제를 실행하면 이전과 동일한 결과를 표시할 것입니다.

(8) 매개변수에 기본값 적용하기

C# 12에서는 lambda 표현식에서 기본값을 제공할 수 있게 되었습니다. 따라서 아래 예제와 같이 표현식을 작성할 수 있습니다.

//var query = names.Where(new Func<string, bool>(NameLongerThanFour));
//var query = names.Where(NameLongerThanFour);
//var query = names.Where(name => name.Length > 3);
var query = names.Where((string name = "홍") => name.Length > 3);

(9) Entity 정렬

다른 일반적으로 사용되는 method로 OrderBy와 ThenBy 등이 있으며 이들은 Sequence를 정렬하기 위해 사용됩니다. 또한 확장 method는 이전 method가 IEnumerable<T> interface를 구현하는 type인 다른 sequence를 반환하는 경우라면 연결(method chain)하여 사용할 수 있습니다.

● OrderBy를 사용한 단일 속성으로 정렬하기

아래 예제와 같이 OrderBy method를 query의 마지막에 추가해 줍니다.

var query = names
	.Where(name => name.Length > 1)
	.OrderBy(name => name.Length);

각각의 확장 method마다 line을 분리하여 형식화하면 좀 더 code를 읽기 쉽게 만들 수 있습니다.

예제를 실행하면 이름이 짧은 순서대로 정렬된 결과를 다음과 같이 표시할 것입니다.

반대로 name이 긴 것 순으로 정렬하고자 한다면 OrderByDescending method를 사용할 수 있습니다.

● ThenBy를 사용한 다수의 속성으로 정렬하기

하나 이상의 속성을 통해 정렬하고자 한다면 예를 들어 alphabet이나 가나다순에서 같은 길이의 name으로 정렬하고자 한다면 아래 예제와 같이 ThenBy를 사용할 수 있습니다.

var query = names
	.Where(name => name.Length > 1)
	.OrderBy(name => name.Length)
	.ThenBy(name => name);

예제를 실행하면 이전과 약간 다른 차이를 알 수 있을 것입니다. 같은 길이의 name으로 정렬된 상태에서 가나다순으로 정렬되었으므로 이도를 제외한 김종서와 김좌진이 상위에 있게 됩니다.

(10) Item 자체에서 정렬하기

.NET 7에서는 Order와 OrderDescending라는 확장 method가 도입되었으며 간단하게 item자체에서 졍렬을 수행할 수 있습니다. 예를 들어 string값의 sequence가 있다면 .NET 7이전에 OrderBy method를 호출하고 item자체를 선택하는 lambda식을 전달해야 했지만

var query = names.OrderBy(name => name);

.NET 7부터는 아래와 같이 간단하게 정렬을 수행할 수 있습니다.

var query = names.Order();

OrderDescending 역시 역순으로 정렬한다는 점을 제외하면 Order와 동일하게 사용할 수 있습니다.

(11) var 또는 특정 type을 사용해 query 선언하기

LINQ 표현식을 작성하는 동안 query개체를 선언하기 위해 var keyword를 사용하는 것은 LINQ 표현식이 동작하는 것마다 type이 자주 바뀔 수 있으므로 매우 일반적인 방법입니다. 예를 들어 예제에서의 query는 IEnumerable<string>으로서 시작되었으나 현재는 IOrderedEnumerable<string>이 되었습니다.

Mouse를 var keyword에 올려두면 type이 IOrderedEnumerable<string>이라는 것을 표시할 것입니다.

따라서 var는 실제 type으로 아래와 같이 바꾸는 것이 가능합니다.

IOrderedEnumerable<string> query = names
	.Where(name => name.Length > 1)
	.OrderBy(name => name.Length)
	.ThenBy(name => name);

일단 query에 대한 작업을 끝내고 나면 var에서부터 선언된 type을 실제 type으로 바꿀 수 있고 이는 type이 정확히 어떤 것인지를 명확히 이해하는데 도움이 될 수 있습니다. 또한 compile시 var가 실제 type으로 바뀌게 되므로 성능에는 영향을 주지 않습니다.

(12) Type filtering

Where 확장 method는 text나 숫자와 같이 값을 통해 filtering 할 수 있지만 sequence가 여러 type을 가지고 있고 이때 상속 계정을 따르면서 특정 type으로 filtering 해야 한다면 다른 방법을 사용해야 합니다.

예를 들어 예외에 대한 sequence가 있다고 가정하면 아래 그림과 같이 복잡한 계층구조로 부터 수백 가지의 예외 type이 형성될 수 있습니다.

그럼 실제 type에 대한 filtering을 예제를 통해 구현해 보겠습니다.

Progam.cs에서 아래와 같이 예외별 파생 개체를 정의합니다.

List<Exception> exceptions = new()
{
		new ArgumentException(),
		new SystemException(),
		new IndexOutOfRangeException(),
		new InvalidOperationException(),
		new NullReferenceException(),
		new InvalidCastException(),
		new OverflowException(),
		new DivideByZeroException(),
		new ApplicationException()
};

이 상태에서 OfType<T> 확장 method를 사용해 arithmetic exception이 아닌 예외를 삭제하고 해당 예외만 console에 표시하는 문을 아래와 같이 작성합니다.

IEnumerable<ArithmeticException> arithmeticExceptionsQuery = exceptions.OfType<ArithmeticException>();
foreach (ArithmeticException exception in arithmeticExceptionsQuery)
{
	Console.WriteLine(exception);
}

위 예제를 실행하면 ArithmeticException 혹은 ArithmeticException으로부터 파생된 type만이 표시됨을 볼 수 있습니다.

(13) LINQ를 사용한 set과 bag

집합은 수학에서 가장 기본적인 개념 중의 하나이며 set은 하나 또는 그 이상의 중복되지 않은 개체의 collection입니다. 반면 Bag라고 하는 multiset(중복집합)은 중복되는 하나 또는 그 이상의 개체에 대한 collection에 해당합니다.

이와 관련하여 학교에서 우리는 이미 Venn diagram이라는 것을 배운 적이 있는데 공통집합 연산에는 집합 간의 교집합 또는 합집합을 포함합니다.

아래 예제에서는 취미별 학생들에 대한 3개의 문자열 값의 array를 정의하고 이들에 대한 공통집합과 합집합을 수행합니다.

우선 project에서 Helpers.cs이름의 class file을 partial class Program으로 추가하고 여기에 아래와 같이 method를 정의합니다. 해당 method는 문자열 변수의 모든 sequence를 comma(,)로 분리한 단일 문자열을 선택적으로 전달하는 설명과 함께 console에 출력하도록 합니다.

partial class Program
{
	static void Output(IEnumerable<string> cohort, string description = "")
	{
		if (!string.IsNullOrEmpty(description))
		{
			Console.WriteLine(description);
		}

		Console.Write(" ");
		Console.WriteLine(string.Join(", ", cohort.ToArray()));
		Console.WriteLine();
	}
}

Program.cs에서는 학생이름에 대한 3개의 문자열 array를 정의하고 이들을 출력한 뒤 다양한 집합연산을 수행하는 문을 아래와 같이 작성합니다.

string[] reading = new[] { "홍길동", "박남일", "김신영", "조정석" };
string[] music = new[] { "윤태진", "박길영", "서만진", "윤태진", "김영수" };
string[] exercise = new[] { "최동만", "이해영", "이해영", "윤태진", "한봉남" };

Output(reading, "독서");
Output(music, "음암감상");
Output(exercise, "운동");

Output(music.Distinct(), "music.Distinct()");
Output(music.DistinctBy(name => name.Substring(0, 2)), "music.DistinctBy(name => name.Substring(0, 2)):");
Output(music.Union(exercise), "music.Union(exercise)");
Output(music.Concat(exercise), "music.Union(exercise)");
Output(music.Intersect(exercise), "music.Intersect(exercise)");
Output(music.Except(exercise), "music.Union(exercise)");
Output(reading.Zip(music, (c1, c2) => $"{c1} matched with {c2}"), "reading.Zip(music)");

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

예제에서 Zip은 2개의 sequences에서 item의 수가 동일하지 않다면 일부 item에서 mathing 되지 않을 수 있습니다. 따라서 music에 '김영수'는 결과에 포함되지 않았습니다.

DistinctBy는 전체이름을 비교하여 중복을 제거하는 대신 이름에서 처음 2글자만 비교하여 제거하기 위해 lambda key selector를 정의하였고 따라서 2명의 '윤태진'중 하나는 제거되었습니다.

지금까지 우리는 LINQ to Objects 공급자를 사용하여 in-memory 개체를 대상으로 예제를 구현하였습니다. 이후부터는 LINQ to Entities 공급자를 사용하여 database에 저장된 entity를 대상으로 예제를 구현해 볼 것입니다.

3. EF Core와 LINQ

위에서는 LINQ query를 통해 filter와 sort를 수행해 보았습니다. 하지만 sequence의 item 형태는 어떤 것도 변함이 없습니다. 이것은 projection이라고 하는 것으로 어떤 형태의 item을 다른 형태로 projecting 하는 것이기 때문입니다.

Projection에 관해 더 알아보려면 좀 더 복잡한 type을 가지고 해 보는 것도 좋은 방법이므로 다음 project에서는 string sequences를 사용하는 대신 이전에 설치했었던 Northwind sample database의 entity sequences를 사용할 것입니다.

(1) EF Core model build

일단 작업의 대상이 될 database와 table을 표현하기 위해 EF Core model을 정의해야 합니다. 따라서 우선은 Categories와 Categories table사이에 자동적으로 관계가 정의되는 것을 막고 완전한 제어권을 가져오기 위해 model을 수동적으로 정의할 것입니다. 그런 다음 LINQ를 사용하여 이 둘의 entity를 join 해 보고자 합니다.

csStudy11 solution에서 LinqWithEFCore이름의 console app project를 생성합니다. 그리고 LinqWithEFCore project에서 SQL Server에 대한 EF Core provider package를 설치합니다. 실제 database는 아래 글에서 이미 설치하였으므로 database를 생성하는 과정은 다루지 않을 것입니다.

[.NET/C#] - [C# 12와 .NET 8] 10. Entity Framework Core

이제 project에 Northwind.cs, Category.cs, Product.cs라는 3개의 class file을 추가할 것입니다. 우선 Northwind.cs file은 아래와 같이 추가합니다.

public class Northwind : DbContext
{
	public DbSet<Category> Categories { get; set; } = null!;

	public DbSet<Product> Products { get; set; } = null!;

	protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
	{
		string connection = "Server=localhost;user id=sa;password=!123;Database=Northwind;MultipleActiveResultSets=true;TrustServerCertificate=true";
		optionsBuilder.UseSqlServer(connection);
	}

	protected override void OnModelCreating(ModelBuilder modelBuilder)
	{
		if ((Database.ProviderName is not null))
		{
			modelBuilder.Entity<Product>().Property(product => product.UnitPrice).HasConversion<double>();
		}
	}
}

Category.cs는 아래와 같이 추가하고

public class Category
{
	public int CategoryId { get; set; }

	[Required]
	[StringLength(15)]
	public string CategoryName { get; set; } = null!;

	public string? Description { get; set; }
}

Product.cs는 아래와 같이 추가합니다.

public class Product
{
	public int ProductId { get; set; }

	[Required]
	[StringLength(40)]
	public string ProductName { get; set; } = null!;
	public int? SupplierId { get; set; }
	public int? CategoryId { get; set; }

	[StringLength(20)]
	public string? QuantityPerUnit { get; set; }

	[Column(TypeName = "money")]
	public decimal? UnitPrice { get; set; }
	public short? UnitsInStock { get; set; }
	public short? UnitsOnOrder { get; set; }
	public short? ReorderLevel { get; set; }
	public bool Discontinued { get; set; }
}

(2) Sequence filtering 하고 sorting 하기

Table로부터 sequence를 filtering 하고 sorting 하기 위해 project에 Functions.cs이름의 class를 file을 추가하고 partial Program class를 정의한 뒤 product를 filter 하고 sort 하는 method를 아래와 같이 추가합니다.

static void FilterAndSort()
{
	using (Northwind db = new())
	{
		DbSet<Product> allProducts = db.Products;

		IQueryable<Product> filteredProducts = allProducts.Where(product => product.UnitPrice < 10M);

		IOrderedQueryable<Product> sortedAndFilteredProducts = filteredProducts.OrderByDescending(product => product.UnitPrice);

		Console.WriteLine("Products that cost less than $10:");

		foreach (Product p in sortedAndFilteredProducts)
		{
			Console.WriteLine("{0}: {1} costs {2:$#,##0.00}", p.ProductId, p.ProductName, p.UnitPrice);
		}

		Console.WriteLine();
	}
}

예제에서 DbSet<T>는 IEnumerable<T>를 구현하고 있으므로 LINQ는 EF Core를 위해 만들어진 model의 entity를 query 하고 조작하기 위해 사용할 수 있습니다. (실제 T대신 TEntity라고 할 수 있지만 해당 generic type의 이름은 기능적인 면을 가지고 있지 않으며 단지 type이 class라는 것만 필요할 뿐입니다. 이름은 그저 class가 entity model이 될 것이라는 예상을 나타낼 뿐입니다.)

Sequence는 또한 IEnumerable<T>혹은 IOrderedEnumerable<T>대신 IQueryable<T> (또는 정렬 LINQ method를 호출하고 나면 IOrderedQueryable<T>)를 구현하고 있습니다. 이는 표현식 tree를 사용해 query를 build 하는 LINQ provider를 사용한다는 것을 나타냅니다. 이들은 tree와 같은 data구조를 나타내고 있으며 동적 query의 생성을 가능하게 하는데 SQLite와 같은 외부 data 공급자를 위해 LINQ query를 build 하는데 유용하게 사용될 수 있습니다.

LINQ표현식은 SQL과 같은 다른 query언어로 변환될 수 있습니다. foreach나 ToArray와 같은 method를 호출하여 query를 열거하게 되면 query를 실행하게 되고 결과를 구체화하게 됩니다.

Program.cs에서 FilterAndSort method를 아래와 같이 호출합니다.

비록 해당 query가 목적한 바에 대한 결과를 표시하고 있기는 하지만 우리가 필요한 3개의 column대신 product table로부터 모든 column들을 가져오고 있기 때문에 상당히 비효휼적이라고 할 수 있습니다. 실제 생성된 SQL문을 확인해 보기 위해 FilterAndSort method를 아래와 같이 수정하고

IOrderedQueryable<Product> sortedAndFilteredProducts = filteredProducts.OrderByDescending(product => product.UnitPrice);

Console.WriteLine(sortedAndFilteredProducts.ToQueryString());

예제를 다시 실행해 보면 product에 대한 filtering결과를 표시하기 전에 실행된 SQL을 다음과 같이 확인할 수 있습니다.

(3) Sequence를 새로운 type으로 projecting 하기

실제 projection을 구현하기 전에 우선은 개체 초기화 구문을 다시 검토해 볼 필요가 있습니다. 정의된 class가 있다면 class명이나 new()를 사용해 해당 개체의 instance를 생성할 수 있으며 괄호를 통해 field나 속성의 초기값을 설정할 수 있습니다.

public class Person
{
    public string Name { get; set; }
    public DateTime DateOfBirth { get; set; }
}

Person knownTypeObject = new()
{
    Name = "dongjunkim",
    DateOfBirth = new(year: 1976, month: 11, day: 14)
};

C# 3.0 이부터는 instance에서 익명 type을 허용하고 있으므로 var keyword를 아래와 같이 사용할 수 있습니다.

var knownTypeObject = new()
{
    Name = "dongjunkim",
    DateOfBirth = new(year: 1976, month: 11, day: 14)
};

비록 type을 명시하지는 않았지만 compiler는 Name과 DateOfBirth라는 이름의 2개의 속성에 대한 설정으로부터 익명 type을 추론할 수 있습니다.

이러한 기법은 특히 새로운 type을 명시적으로 정의하지 않고 기존 type에서 새로운 type으로 project 하기 위해 LINQ query를 작성할 때 도움이 될 수 있습니다. Type은 익명이기에 var 선언된 지역변수에서만 작동할 수 있습니다.

아래 예제는 Product class의 instance를 새로운 익명 type으로 투영하기 위한 select method의 호출을 추가함으로써 database table을 상대로 SQL명령을 더 효휼적으로 실행하는 방식을 보여주고 있습니다.

Functions.cs의 FilterAndSort method에서 실제 필요로 하는 세 개의 속성(table의 column에 해당하는)만을 반환하는 Select method를 사용하기 위해 LINQ query를 확장하는 문을 아래와 같이 추가하고 var keyword와 projection LINQ 표현식을 사용하도록 아래와 같이 foreach문을 변경합니다.

IOrderedQueryable<Product> sortedAndFilteredProducts = filteredProducts.OrderByDescending(product => product.UnitPrice);

var projectedProducts = sortedAndFilteredProducts.Select(product => new { product.ProductId, product.ProductName, product.UnitPrice });

Console.WriteLine(projectedProducts.ToQueryString());

Console.WriteLine("Products that cost less than $10:");

foreach (var p in projectedProducts)
{
	Console.WriteLine("{0}: {1} costs {2:$#,##0.00}", p.ProductId, p.ProductName, p.UnitPrice);
}

이때 Select method에서 new keyword와 foreach문의 var keyword에 mouse를 올려두면 이것이 익명 type임을 다음과 같이 표시할 것입니다.

예제를 실행하면 이전과 같은 결과를 표시하지만 생성된 SQL은 더 효휼적으로 바뀌었음을 알 수 있습니다.

(4) Sequence에 대한 join과 grouping

Joining과 grouping을 위해 사용할 수 있는 확장 method로 아래와 같은 3가지가 있습니다.

Join : 해당 method는 join 하고자 하는 sequence 및 연결시킬 left sequence와 right sequence에 해당하는 속성, 그리고 projection인 4개의 매개변수를 필요로 합니다.
GroupJoin : 해당 method 역시 같은 매개변수를 필요로 하지만 일치하는 항목들을 일치하는 값에 대한 key속성과 다중 일치항목에 대한 IEnumerable<T> type을 가진 group개체로 결합합니다.
ToLookup : 해당 method는 기존의 sequence에서 key를 통해 group화된 것을 토대로 새로운 data구조를 생성합니다.

● Sequence Join

예를 들어 Categories와 Products라는 2개의 table을 join 하고자 하는 경우 Functions.cs에서 categories와 products를 select 하고 이들을 join 하여 출력하는 method를 아래와 같이 추가할 수 있습니다.

static void JoinCategoriesAndProducts()
{
	using (Northwind db = new())
	{
		//Products를 Categories와 join함
        var queryJoin = db.Categories.Join(
			inner: db.Products,
			outerKeySelector: category => category.CategoryId,
			innerKeySelector: product => product.CategoryId,
			resultSelector: (c, p) => new { c.CategoryName, p.ProductName, p.ProductId }
		);
        foreach (var item in queryJoin)
        {
            Console.WriteLine("{0}: {1} is in {2}.", arg0: item.ProductId, arg1: item.ProductName, arg2: item.CategoryName);
        }
    }
}

Join에서는 outer와 inner라는 2개의 sequence가 존재합니다. 위의 예제에서 categories는 outer sequence가 되고 products는 inner sequence가 됩니다.

Program.cs에서는 JoinCategoriesAndProducts method를 호출하도록 한 뒤 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

query의 끝에서 CategoryName에 대한 정렬을 위해 OrderBy method를 아래와 같이 호출할 수 있습니다.

var queryJoin = db.Categories.Join(
	inner: db.Products,
	outerKeySelector: category => category.CategoryId,
	innerKeySelector: product => product.CategoryId,
	resultSelector: (c, p) => new { c.CategoryName, p.ProductName, p.ProductId }
).OrderBy(cp => cp.CategoryName);

결과를 실행해 보면 처음에는 Beverages category에 대한 모든 product들이 나오고 그다음 Condiments category에 대한 것들 등.. 의 순서로 결과가 표시됨을 알 수 있습니다.

● Sequence group-Joining

위에서 join 하기에 사용했던 Categories와 Products 이 2개의 table에 대해 group-joining을 해봄으로써 약간의 차이를 비교해 볼 수 있습니다.

Functions.cs에서 group과 join을 수행하고 group name과 각 group에서의 모든 item을 표시하는 method를 아래와 같이 추가합니다.

static void GroupJoinCategoriesAndProducts()
{
	using (Northwind db = new())
	{
        var queryGroup = db.Categories.AsEnumerable().GroupJoin(
			inner: db.Products,
			outerKeySelector: category => category.CategoryId,
			innerKeySelector: product => product.CategoryId,
			resultSelector: (c, matchingProducts) => new
			{
				c.CategoryName,
				Products = matchingProducts.OrderBy(p => p.ProductName)
			});

        foreach (var category in queryGroup)
        {
            Console.WriteLine("{0} has {1} products.", arg0: category.CategoryName, arg1: category.Products.Count());
            foreach (var product in category.Products)
            {
                Console.WriteLine($" {product.ProductName}");
            }
        }
    }
}

만약 예제에서처럼 AsEnumerable method를 호출하지 않는다면 다음과 같은 runtime 예외가 발생할 것입니다.

이는 모든 LINQ 확장 method가 표현식 tree로부터 SQL과 같은 일부 다른 query문으로 변환되지 않기 때문입니다. 이 경우 예제는 application으로 data를 가져오기 위한 LINQ to EF Core사용을 위해 query처리를 강제하고 memory에서 더 복잡한 처리를 실행하기 위한 LINQ to Objects를 사용하는 AsEnumerable method를 호출함으로써 IQueryable<T>에서 IEnumerable<T>로 변환하고 있습니다. 하지만 대게 이러한 처리는 효율성면에서 더 떨어질 수 있습니다.

Program.cs에서 GroupJoinCategoriesAndProducts method를 호출하도록 한 뒤 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

결과를 보면 각 category에 포함된 product들이 query에서 정의된 것처럼 이름순으로 정렬되어 있음을 알 수 있습니다.

● lookup을 위한 group화

LINQ query 표현식을 통해 join과 group를 작성하는 대신 lookup 확장 method를 통해 entity를 group화한 개체를 생성하고 memory에 개체를 저장할 수 있습니다.

Northwind의 database의 Products table을 보면 category를 위한 일부 column이 포함되어 있음을 알 수 있습니다.

Product	Category
Chai	1
Chang	1
Aniseed Syrup	2
Chef Anton’s Cajun Seasoning	2
Chef Anton’s Gumbo Mix	2

이 상태에서 category별로 product의 entity를 그룹화한 data구조를 생성하고자 한다면 아래와 같이 구현할 수 있습니다.

ILookup<int, Product> productsByCategoryId = db.Products.ToLookup(keySelector: category => category.CategoryId);

ToLookup method에서는 group화에 사용될 값으로서 key selector를 지정해야 합니다. 이를 통해 key와 값을 가진 dictionary형태의 data를 생성하게 되며 이때 key는 category ID가 되고 값은 Product 개체의 collection이 됩니다.

key	value
1	Chai, Chang...
2	Aniseed Syrup, Chef Anton’s Cajun Seasoning, Chef Anton’s Gumbo Mix, ...
...	...

(5) Sequences 집계하기

LINQ 확장 method 중에는 집계기능을 수행하는 Average나 Sum과 같은 것들이 존재합니다. 아래 예제를 통해 이들 method를 사용하여 Products에 대한 집계정보를 확인하는 방법을 알 수 있습니다.

Functions.cs에서 다음과 같이 다양한 집계 확장 method를 사용하는 method를 추가합니다.

static void AggregateProducts()
{
	using (Northwind db = new())
	{
        if (db.Products.TryGetNonEnumeratedCount(out int countDbSet))
        {
            Console.WriteLine("{0,-25} {1,10}", arg0: "Product count from DbSet:", arg1: countDbSet);
        }
        else
        {
            Console.WriteLine("Products DbSet does not have a Count property.");
        }

        List<Product> products = db.Products.ToList();

        if (products.TryGetNonEnumeratedCount(out int countList))
        {
            Console.WriteLine("{0,-25} {1,10}", arg0: "Product count from list:", arg1: countList);
        }
        else
        {
            Console.WriteLine("Products list does not have a Count property.");
        }

        //aggregation extension methods
        Console.WriteLine("{0,-25} {1,10}", arg0: "Product count:", arg1: db.Products.Count());
        Console.WriteLine("{0,-27} {1,8}", arg0: "Discontinued product count:", arg1: db.Products.Count(product => product.Discontinued));
        Console.WriteLine("{0,-25} {1,10:$#,##0.00}", arg0: "Highest product price:", arg1: db.Products.Max(p => p.UnitPrice));
        Console.WriteLine("{0,-25} {1,10:N0}", arg0: "Sum of units in stock:", arg1: db.Products.Sum(p => p.UnitsInStock));
        Console.WriteLine("{0,-25} {1,10:N0}", arg0: "Sum of units on order:", arg1: db.Products.Sum(p => p.UnitsOnOrder));
        Console.WriteLine("{0,-25} {1,10:$#,##0.00}", arg0: "Average unit price:", arg1: db.Products.Average(p => p.UnitPrice));
        Console.WriteLine("{0,-25} {1,10:$#,##0.00}", arg0: "Value of units in stock:", arg1: db.Products.Sum(p => p.UnitPrice * p.UnitsInStock));
    }
}

Count를 확인하는 것은 단순한 동작처럼 보이지만 처리비용이 많이 들 수 있습니다. Products와 같은 DbSet<T>는 Count 속성을 가지고 있지 않으므로 TryGetNonEnumeratedCount는 false를 반환합니다. 하지만 products 같은 List<T>는 ICollection을 구현하므로 Count속성을 가지고 있고 따라서 TryGetNonEnumeratedCount는 true를 반환합니다. (이 경우 그 자체로 비용이 많이 드는 list를 instance화 해야 했지만 이미 list가 있고 item의 수를 알아야 한다면 이것이 더 효율적일 수 있습니다.) DbSet<T>에서 언제나 Count() 호출할 수 있지만 이는 sequence를 열거해야 하므로 느릴 수 있으며 lambda 식을 Count()에 전달하여 sequence의 count되어야할 item을 filter할 수 있지만 Count나 Length는 사용할 수 없습니다.

Program.cs에서 AggregateProducts method를 호출하도록 하고 예제를 실행하면 다음과 같은 결과를 볼 수 있습니다.

(6) 빈 sequence를 확인하는 방법

빈 sequence를 확인하는데는 아래와 같은 방법이 존재합니다.

● Count method

LINQ의 Count method를 호출하여 결과가 0이상인지를 확인합니다. 이 방법은 sequence items 전체를 열거해야 하므로 좋은 방법은 아닙니다. Sequence가 ICollection 혹은 ICollection<T>를 구현하고 있으면 Count 속성이 더 효휼적인 방법일 수 있습니다.

● Any method

LINQ의 Any method를 호출하여 true여부를 확인합니다. Count method보다는 괜찮지만 아래 2가지 방법을 사용할 수 있다면 추천하지 않습니다.

● Count 속성

Sequence의 Count 속성을 사용하여 0이상인지를 확인합니다. ICollection 혹은 ICollection<T>를 구현하는 모든 sequence는 Count속성을 가집니다.

● Length 속성

Sequence의 Length속성을 사용하여 0이상인지를 확인합니다. 기본적으로 모든 array는 Length속성을 가집니다.

해당 Sequence가 Count나 Length속성을 가지고 있다면 해당 속성을 가장 우선적으로 사용하는 것이 좋습니다.

(7) Count에서의 주의점

Amichai Mantinband은 Microsoft의 software engineer로서 C#과 .NET 개발자 stack의 흥미로운 부분에 대한 주목할만한 일을 하고 있습니다.

최근 그는 Twitter, LinkedIn, YouTube에 개발자들이 이 code가 무엇을 할 것이라고 생각하는지를 알아보기 위한 설문과 함께 code teaser를 post 했습니다.

그의 code는 이렇습니다.

IEnumerable<Task> tasks = Enumerable.Range(0, 2).Select(_ => Task.Run(() => Console.WriteLine("*")));
await Task.WhenAll(tasks);
Console.WriteLine($"{tasks.Count()} stars!");

위 code의 결과는 무엇일까요?

**2 stars!
**2 stars!**
****2 stars!
이외 다른 것

그런데 설문결과 대부분 틀린 것을 골랐습니다. 여기서 말하고자 하는 핵심이 바로 이것이며 위와 같은 까다로운 질문에서 task와 함께 multi-threadiing의 세부적인 부분 까지는 아니더라도 LINQ부분을 살펴볼 수 있습니다. 위 code에서는 LINQ부분을 이해하기 위해 아래와 같이 code를 분리해 보겠습니다.

Enumerable.Range(0, 2)	0과 1의 두 정수에 대한 sequence를 반환합니다. code를 좀더 명확히 하기위해 이 부분에서 명명된 매개변수를 아래와 같이 추가할 수도 있을 것입니다. Enumerable.Range(start: 0, count: 2)
Select(_ => Task.Run(...)	두 숫자 각각에서 자체 thread를 가진 task를 생성합니다. 이때 _ 매개변수는 숫자값을 버리게 되며 각각의 task는 console로 *을 표시하게 됩니다.
await Task.WhenAll(tasks);	두 task가 완료될때까지 main thread를 block하게 되며 2개의 *문자가 console에 표시됩니다.
tasks.Count()	해당 scenario에서 LINQ Count() method가 작동하려면 sequence를 열거해야 하며 이렇게 하면 2개의 task를 다시 실행시킬 수 있습니다. 다만 이 2개의 task가 실행될 시점을 알 수 없고 2의 값이 호출한 method로 부터 반환됩니다.
Console.WriteLine( $"... stars!");	'2 stars!'가 console에 출력됩니다.

따라서 우리는 **이 console에 먼저 출력되고 그다음 하나 또는 2개의 task가 *을 출력하고 그 뒤 '2 stars!'가 출력된다는 것을 알 수 있습니다. 마지막으로 하나 또는 2개의 task가 이전에 수행할 시간이 없거나 main thread가 종료되어 task가 *을 출력하기 전에 console app을 종료할 수 있는 경우 *을 출력할 수 있으므로 결과를 다음과 같을 것입니다.

**[각 task는 여기에 *을 출력할 수도 있음]2 starts![각 task는 여기에 *을 출력할 수 있음]

따라서 Amichai의 teaser에 대한 가장 정확한 답은 'Something else'일 것입니다.

반환값을 계산하기 위해 sequence전체를 열거해야 하는 Count 등의 LINQ 확장 method를 호출할 때는 주의가 필요합니다. Task와 같이 실행가능한 개체의 sequence를 사용하지 않는다 하더라도 sequence를 다시 열거하는 것은 비효율적일 수 있습니다.

(8) LINQ를 사용한 paging

Skip과 Take 확장 method를 사용하면 paging을 구현할 수 있습니다.

Functions.cs에서 아래와 같이 array로 전달한 products의 table을 console에 출력하는 method를 추가합니다.

static void OutputTableOfProducts(Product[] products, int currentPage, int totalPages)
{
    string line = new('-', count: 73);
    string lineHalf = new('-', count: 30);

    Console.WriteLine(line);
    Console.WriteLine("{0,4} {1,-40} {2,12} {3,-15}", "ID", "Product Name", "Unit Price", "Discontinued");
    Console.WriteLine(line);

    foreach (Product p in products)
    {
        Console.WriteLine("{0,4} {1,-40} {2,12:C} {3,-15}", p.ProductId, p.ProductName, p.UnitPrice, p.Discontinued);
    }

    Console.WriteLine("{0} Page {1} of {2} {3}", lineHalf, currentPage + 1, totalPages + 1, lineHalf);
}

일반적인 programming세계에서 순서는 0부터 시작합니다. 따라서 currentPage count와 totalPages count에 대한 값을 사용자에게 표시하기 전 1을 더해줄 필요가 있습니다.

계속해서 products에 대한 page를 만드는 LINQ query를 생성하고 여기서 만들어진 SQL을 출력한 뒤 products의 table을 표시하는 method에서 products의 array로 해당 결과를 전달하는 method를 아래와 같이 추가합니다.

static void OutputPageOfProducts(IQueryable<Product> products, int pageSize, int currentPage, int totalPages)
{
    // skip과 take전에 data를 정렬하여 각 page에서 data가 임의의 순서로 나오지 않도록 해야 합니다.
    var pagingQuery = products.OrderBy(p => p.ProductId).Skip(currentPage * pageSize).Take(pageSize);

    OutputTableOfProducts(pagingQuery.ToArray(), currentPage, totalPages);
}

마지막으로 사용자가 왼쪽(left) 혹은 오른쪽(right) 화살표를 눌러 database의 products를 한 번에 한 page씩 표시하도록 순환하는 method를 같이 추가합니다.

static void PagingProducts()
{
	using (Northwind db = new())
	{
		int pageSize = 10;
		int currentPage = 0;
		int productCount = db.Products.Count();
		int totalPages = productCount / pageSize;

		while (true)
		{
            OutputPageOfProducts(db.Products, pageSize, currentPage, totalPages);
            Console.Write("Press <- to page back, press -> to page forward, any key to exit.");

            ConsoleKey key = Console.ReadKey().Key;

            if (key == ConsoleKey.LeftArrow)
                if (currentPage == 0)
                    currentPage = totalPages;
                else
                    currentPage--;
            else if (key == ConsoleKey.RightArrow)
                if (currentPage == totalPages)
                    currentPage = 0;
                else
                    currentPage++;
            else
                break; // loop 탈출

            Console.WriteLine();
        }
    }
}

Program.cs에서는 PagingProducts method를 호출하도록 하고 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

위 예제의 결과에서 ORDER BY, LIMIT, OFFSET 등을 사용해 products의 page를 효휼적으로 가져오기 위해 사용된 SQL문의 표시는 제외하였습니다.

왼쪽, 오른쪽 key를 누르면 page를 전환할 수 있고 그 외 다른 key를 누르면 program을 빠져나오게 됩니다.

Paging을 위해 Skip과 Take를 호출하는 경우라면 그전에 data를 정렬해야 합니다. 이는 query가 실행될 때마다 ProductId순이나 UnitPrice순 혹은 심지어 random처럼 특정 기준으로의 정렬이 요청될 수 있으므로 LINQ 공급자가 같은 순서의 data가 반환된다는 것을 보증하지 않기 때문입니다. 관계형 database에서 대게는 primary key상의 index순으로 사용하는 경우가 많습니다.

4. LINQ 구문의 향상기법

C# 3.0에서는 2008년에 SQL경험을 가진 개발자가 LINQ query를 더 쉽게 만들기 위한 몇 가지 새로운 언어 keyword를 도입하였으며 이를 LINQ query 이해(comprehension) 구문이라고 합니다.

예를 들어 다음과 같은 문자열형식의 array가 존재할 때

string[] names = new[] { "이순신", "이도", "신사임당", "홍길동", "김종서", "박혁거세", "김좌진", "윤봉길" };

이름별로 filter 하고 정렬하기 위해 아래와 같이 확장 method와 lambda 식을 사용할 수 있습니다.

var query = names
    .Where(name => name.Length > 3)
    .OrderBy(name => name.Length)
    .ThenBy(name => name);

또는 같은 결과를 만들어내기 위해 아래와 같이 query 이해 문을 사용할 수도 있습니다.

var query = from name in names
            where name.Length > 3
            orderby name.Length, name
            select name;

이러한 방식이 작동할 수 있는 이유는 compiler가 query 이해 문을 이전예제와 동일하게 확장 method와 lambda 식으로 변환하기 때문입니다.

select keyword는 LINQ query 이해 구문에서 반드시 필요한 존재합니다. 하지만 Select 확장 method는 확장 method와 lambda 식을 사용할 때 Select를 호출하지 않으면 item전체가 암시적으로 선택되므로 선택적으로 사용할 수 있습니다.

모든 확장 method가 C# keyword와 동일하게 연결되지는 않습니다. 예를 들어 Skip과 Take 확장 method는 일반적으로 많은 data에서 paging을 구현하는 데 사용되곤 합니다. Query comprehense만으로 작성될 수 없는 skip과 take query는 모두 확장 method를 사용해 다음과 같이 작성할 수 있습니다.

var query = names
    .Where(name => name.Length > 3)
    .Skip(80)
    .Take(10);

또는 괄호를 통해 query 이해 문을 감싸고 난 후 이를 확장 method로 연결하여 사용할 수도 있습니다.

var query = (from name in names
                where name.Length > 4
                select name)
                .Skip(80)
                .Take(10);

5. 사용자 LINQ 확장 method 정의하기

아래 글을 통해서 우리는 이미 자신만의 확장 method를 생성하는 방법을 알아보았습니다.

2024.02.20 - [.NET/C#] - [C# 12와 .NET 8] 6. Interface와 Class상속

LINQ 확장 method를 만들기 위해 해야 할 것은 IEnumerable<T> type을 확장하는 것이 전부입니다.

직접 정의한 method는 별도의 class file을 만들어 분리해 두면 자체 assembly나 NuGet package 등으로 배포하기 수훨해 질 수 있습니다.

예를 들어 우리는 평균을 아래 3가지 중 하나가 될 수 있음을 말할 수 있는데

Mean : 수를 합산하고 건수로 나눈 것
Mode : 가장 일반적인 숫자
Median : 정렬되고 난 후의 숫자 중에서 중간값

Microsoft는 Average 확장 method를 mean으로 계산되도록 구현하였으므로 여기서 Average method를 위에서 언급한 Mode와 Median계산이 가능하도록 해야 한다면 다음과 같은 방법으로 method를 정의할 수 있습니다.

Project에 MyLinqExtensions.cs file을 아래와 같이 추가합니다.

namespace LinqWithEFCore
{
    public static class MyLinqExtensions
    {
        // chain LINQ extension method
        public static IEnumerable<T> ProcessSequence<T>(this IEnumerable<T> sequence)
        {
            // you could do some processing here
            return sequence;
        }

        public static IQueryable<T> ProcessSequence<T>(this IQueryable<T> sequence)
        {
            // you could do some processing here
            return sequence;
        }

        // scalar LINQ extension methods
        public static int? Median(this IEnumerable<int?> sequence)
        {
            var ordered = sequence.OrderBy(item => item);
            int middlePosition = ordered.Count() / 2;

            return ordered.ElementAt(middlePosition);
        }

        public static int? Median<T>(this IEnumerable<T> sequence, Func<T, int?> selector)
        {
            return sequence.Select(selector).Median();
        }

        public static decimal? Median(this IEnumerable<decimal?> sequence)
        {
            var ordered = sequence.OrderBy(item => item);
            int middlePosition = ordered.Count() / 2;

            return ordered.ElementAt(middlePosition);
        }

        public static decimal? Median<T>(this IEnumerable<T> sequence, Func<T, decimal?> selector)
        {
            return sequence.Select(selector).Median();
        }

        public static int? Mode(this IEnumerable<int?> sequence)
        {
            var grouped = sequence.GroupBy(item => item);
            var orderedGroups = grouped.OrderByDescending(group => group.Count());

            return orderedGroups.FirstOrDefault()?.Key;
        }

        public static int? Mode<T>(this IEnumerable<T> sequence, Func<T, int?> selector)
        {
            return sequence.Select(selector)?.Mode();
        }

        public static decimal? Mode(this IEnumerable<decimal?> sequence)
        {
            var grouped = sequence.GroupBy(item => item);
            var orderedGroups = grouped.OrderByDescending(group => group.Count());

            return orderedGroups.FirstOrDefault()?.Key;
        }

        public static decimal? Mode<T>(this IEnumerable<T> sequence, Func<T, decimal?> selector)
        {
            return sequence.Select(selector).Mode();
        }
    }
}

Class가 별도의 class library로 분리되어 있다면 LINQ 확장 method를 사용하기 위해서는 그저 class library assembly를 참조하기만 하면 됩니다. 참고로 System.Linq namespace는 이미 암시적으로 import 되는 것이 기본이기 때문에 대부분 별다른 추가작업이 필요 없지만 그렇지 않다면 System.Linq도 import 되어야 합니다.

상기 예제의 모든 method 중 하나를 제외하고 그 외 다른 method는 SQL과 같은 query언어로 변환하는 것까지 구현하지 않았기 때문에 LINQ to SQLite 또는 LINQ to SQL Server에서 사용된 것과 같은 IQueryable sequence와 함께 사용할 수 없습니다.

(1) Chainable extension method

상기 예제에서 처음 2개의 method는 ProcessSequence method와의 chaining이 가능한 method입니다.

Functions.cs의 FilterAndSort method에서 Products에 대한 LINQ query를 아래와 같이 변경하여 예제의 확장 method를 호출하도록 합니다.

DbSet<Product> allProducts = db.Products;

IQueryable<Product> processedProducts = allProducts.ProcessSequence();
				
IQueryable<Product> filteredProducts = processedProducts.Where(product => product.UnitPrice < 10M);

Program.cs에서는 FilterAndSort method를 호출하도록 하고 예제를 실행하면 이전과 같은 결과를 볼 수 있을 것입니다. 여기서는 예제의 ProcessSequence method가 실제 sequence를 변경하는 것은 아니지만 이러한 구현을 통해 LINQ표현식을 위 method처럼 확장할 수 있다는 것을 알 수 있습니다.

● Mode와 median method 구현

다른 종류의 평균을 계산하기 위한 Mode and Median method를 사용하기 위해 Functions.cs에서 products의 UnitPrice와 UnitsInStock에 대한 mean, median, mode를 이전 예제에서 구현한 확장 method와 기본 내장 Average extension method를 사용해 출력하는 method를 아래와 같이 추가합니다.

static void CustomExtensionMethods()
{
	using (Northwind db = new())
	{
        Console.WriteLine("{0,-25} {1,10:N0}", "Mean units in stock:", db.Products.Average(p => p.UnitsInStock));
        Console.WriteLine("{0,-25} {1,10:$#,##0.00}", "Mean unit price:", db.Products.Average(p => p.UnitPrice));
        Console.WriteLine("{0,-25} {1,10:N0}", "Median units in stock:", db.Products.Median(p => p.UnitsInStock));
        Console.WriteLine("{0,-25} {1,10:$#,##0.00}", "Median unit price:", db.Products.Median(p => p.UnitPrice));
        Console.WriteLine("{0,-25} {1,10:N0}", "Mode units in stock:", db.Products.Mode(p => p.UnitsInStock));
        Console.WriteLine("{0,-25} {1,10:$#,##0.00}", "Mode unit price:", db.Products.Mode(p => p.UnitPrice));
    }
}

Program.cs에서는 CustomExtensionMethods를 호출하도록 하고 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

참고로 $18.00인 products는 4개이고 재고가 0개인 products는 5개입니다.

6. LINQ to XML

LINQ to XML은 query에 대한 결과를 XML로 가져올 수 있도록 하는 LINQ 공급자입니다.

(1) LINQ to XML을 사용한 XML 생성

예를 들어 Products table을 XML로 변환하고자 한다면 products를 XML형식으로 출력하는 method를 다음과 같이 추가할 수 있습니다.

static void OutputProductsAsXml()
{
	using (Northwind db = new())
	{
        Product[] productsArray = db.Products.ToArray();

        XElement xml = new("products",
			from p in productsArray
			select new XElement("product", new XAttribute("id", p.ProductId), new XAttribute("price", p.UnitPrice), new XElement("name", p.ProductName)));
                
		Console.WriteLine(xml.ToString());
    }
}

Program.cs에서 OutputProductsAsXml method를 호출하도록 한 뒤 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

생성된 XML의 구조는 XML 요소와 위 예제에서 선언적으로 서술된 LINQ to XML문의 attribute와 일치합니다.

(2) LINQ to XML을 사용한 XML parsing

LINQ to XML을 사용하면 XML file을 쉽게 질의하거나 처리할 수 있습니다.

Project에 settings.xml이름의 XML file을 아래와 같이 추가합니다.

<?xml version="1.0" encoding="utf-8" ?>
<memberSettings>
	<add key="Name" value="hong" />
	<add key="Age" value="30" />
	<add key="WorkGroup" value="IT" />
</memberSettings>

Visual Studio 2022는 compile 된 application이 bin\Debug\net7.0 folder에서 실행되므로 추가한 XML을 해당 folder로 복사되도록 해야 합니다. 따라서 XML file을 선택하고 'Copy to Output Directory'의 속성을 'Copy always'로 변경해야 합니다.

Functions.cs에서는 아래와 같은 method를 추가합니다.

static void ProcessSettings()
{
	string path = Path.Combine(Environment.CurrentDirectory, "settings.xml");

	Console.WriteLine($"Settings file path: {path}");

	XDocument doc = XDocument.Load(path);
	var memberSettings = doc.Descendants("memberSettings").Descendants("add")
	.Select(node => new
	{
		Key = node.Attribute("key")?.Value,
		Value = node.Attribute("value")?.Value
	}).ToArray();
	foreach (var item in memberSettings)
	{
		Console.WriteLine($"{item.Key}: {item.Value}");
	}
}

위 method는 XML file을 load 하여 LINQ to XML을 사용해 memberSettings이름의 요소와 하위 add요소를 찾습니다. 그런 다음 XML을 Key와 Value 속성을 가진 익명 type의 array로 구체화한뒤 이를 열거하도록 합니다.

Program.cs에서 ProcessSettings method를 호출하고 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

[C# 12와 .NET 8] 10. Entity Framework Core

클리엘 — Thu, 7 Mar 2024 16:46:08 +0900

Entity Framework Core (이하 EF Core)는 SQLite나 SQL Server와 같은 관계형 database에 data를 읽고 쓰기 위한 객체-데이터 저장 mapping 기술입니다.

1. Database

Database에는 크게 2가지 종류가 있는데 하나는 RDBMS(Relational Database Management System)으로 SQL Server, PostgreSQL, MySQL, SQLite 등이 있고 다른 하나는 NoSQL로서 Azure Cosmos DB, Redis, MongoDB, Apache Cassandra 등이 있습니다.

관계형 database는 1970년대 개발된 것으로 SQL(Structured Query Language)을 통해 data를 질의합니다. 그 당시 data를 저장하는데는 많은 비용이 소모되었으므로 가능한 한 data의 중복을 최소화해야 했습니다. Data는 행(Row)과 열(Column)로 이루어진 table구조에 저장되었는데 일단 완성되고 나면 refactor 하기에는 까다로운 구조였습니다.

NoSQL은 단순히 SQL이 없음을 의미하지는 않습니다. 다른 뜻으로는 굳이 SQL일 필요가 없다는 의미가 될 수도 있습니다. 2000년대부터 개발되어온 NoSQL은 당시 Internet과 Web이 대중화되고 software에 관한 많은 학습이 이루어지던 시기였으며 또한 막대한 확장성과 고성능을 위해 설계되었고 최대한의 유연성을 제공함으로써 개발자들의 집입장벽을 낮추었습니다. 또한 구조를 강제하지 않음으로써 이들 사이에서는 언제든 schema를 변경할 수 있는 특징이 있습니다.

(1) 과거 Entity Framework

Entity Framework는 2008년 말 Service pack 1과 함께 .NET Framework 3.5의 일부로 처음 출시되었습니다. 그런 후 Entity Framework는 지금까지 계속해서 발전을 거듭하고 있습니다.

ORM은 mapping정의를 사용하여 class의 속성을 table의 column으로 연결합니다. 그러면 개발자는 관계형 table 혹은 NoSQL data store에 의해 제공된 다른 구조로 값을 어떻게 저장해야 할지 알아야 하는 대신 자신에게 친숙한 방식으로 다른 type 간 개체를 통해 상호작용할 수 있습니다.

.NET Framework에 포함된 EF의 version은 Entity Framework 6 (EF6)로서 성숙되고 안정적이며 복잡한 상속 model뿐 아니라 model을 정의하는 EDMX(XML file)와 그 외 몇 가지 향상된 기능을 지원합니다.

EF 6.3부터는 .NET Framework에서 별도의 package로 분리되어 .NET Core 3.0부터 지원이 가능하게 되었습니다. Web application이나 service와 같은 기존 project에서 cross-platform으로 이식하고 동작할 수 있으나 EF6는 cross-platform에서 동작시 일부 제한적이며 더 이상 새로운 기능이 추가되지 않으므로 legacy technology로 간주되고 있습니다.

● Entity Framework의 사용

Legacy technology인 Entity Framework를 .NET Core 3.0이나 이후 project에서 사용하려면 project file에서 아래와 같이 package 참조를 추가해야 합니다.

<PackageReference Include="EntityFramework" Version="6.4.4" />

예전 WPF app을 migration하는 경우와 같은 상황만 필요하다면 EF6를 사용해야 합니다.

(2) Entity Framework Core

진정한 cross-platform version인 EF Core는 Entity Framework와의 가장 큰 차이라고 할 수 있습니다. 비록 EF Core가 이름이 비슷하기는 하지만 EF6와는 분명히 다른 것입니다. 가장 최신의 EF Core version은 8이며 .NET8과 일치합니다.

EF Core 5부터는 .NET5와 그 이후만 지원하며 그 이하 EF Core 3은 .NET Standard 2.1을 지원하는 platform에서만 동작합니다. EF Core 3부터는 .NET Framework 4.8과 같은 .NET Standard 2.0 platform을 지원하지 않습니다.

EF Core 8은 .NET 8부터의 version을 target으로 합니다. 다시 말해 EF Core 8에서의 모든 새로운 기능은 .NET 8혹은 .NET 9에서만 사용할 수 있습니다. 만약 현재 .NET 7을 사용 중이라면 version 8에서 참조하는 EF Core package를 upgrade 할 것을 권장합니다.

전통적인 RDBMS뿐만 아니라 EF Core는 cloud기반의 비관계형 Database인 Azure Cosmos DB와 MongoDB등도 지원하고 있습니다.

EF Core는 많은 개선점을 가지고 있지만 이 모두를 다루지는 않을 것입니다. 예를 들어 EF Core 7과 함께 도입된 새로운 기능에는 JSON 문서를 저장하는 column을 가질 수 있는 database가 해당 문서를 질의하고 filter와 정렬 표현식에서 문서의 요소를 사용하는 JSON column을 지원하지만 EF Core 7에서 JSON column 기능은 단지 SQL Server를 위해서만 구현됩니다. 향후 EF Core version은 SQLite와 같은 다른 database도 추가될 테고 그 시점에 해당 내용을 다루게 될지도 모르지만 현재는 개발자가 알아야 할 기본적인 사항과 일부 유용한 기능을 살펴보는데만 집중할 것입니다.

(3) Database First와 Code First

EF core를 사용하기 위해서는 아래 2가지 방법을 선택할 수 있습니다.

Database First : Database가 이미 존재하는 상태에서 구조및 특징과 일치하는 model을 build 합니다.
Code First : Database가 존재하지 않는다면 model을 build 한 뒤 해당 구조 및 특징과 일치하는 database를 EF Core를 사용해 생성합니다.

(4) EF Core에서의 성능 향상

EF Core team은 EF Core의 성능향상을 위해 많은 노력을 기울여 왔습니다. 예를 들어 EF Core 7이 SaveChanges가 호출될 때 database에 대해 단일문만이 실행된다고 식별하는 경우 이전 version과 마찬가지로 명시적인 transaction을 생성하지 않습니다. 이와 같은 방식은 일반적인 경우에서 약 25% 정도의 성능향상을 기대할 수 있습니다.

이와 같이 내부적으로 적용된 최신의 개선사항들은 이들이 어떻게 동작하는가에 대한 이해가 없이도 사용하는 것만으로 그에 대한 혜택을 얻을 수 있습니다. 만약 이러한 세부적인 사항에 관심이 있다면(특히 일부 멋진 SQL Server 기능을 활용한 방식에 대해) EF Core team이 작성한 아래 글을 읽어보시길 바랍니다.

Announcing Entity Framework Core 7 Preview 6: Performance Edition (microsoft.com)

Announcing Entity Framework Core 7 Preview 6: Performance Edition - .NET Blog

Announcing Entity Framework Core 7 Preview 6 with update performance optimizations.

devblogs.microsoft.com

Announcing Entity Framework Core 6.0 Preview 4: Performance Edition (microsoft.com)

Announcing Entity Framework Core 6.0 Preview 4: Performance Edition - .NET Blog

EF Core 6.0 Preview 4 is here and has the best performance ever. Read this post to learn how the team boosted speed by 70% over EF Core 5.0!

devblogs.microsoft.com

(5) EF Core를 사용한 console app 만들기

우선 console app을 만들기 위해 csStudy10 solution을 생성하고 그 안에 WorkingWithEFCore이름의 Console App project를 추가합니다.

(6) Sample database

.NET을 통해 RDBMS를 어떻게 사용할 수 있을지를 알아보기 위해서는 적당한 수의 record와 적당한 수준의 복잡도를 가진 sample database가 필요합니다. 이를 위해 Microsoft는 몇 가지 sample database를 제공하고 있는데 너무 복잡한 것을 제외하고 사용가능한 가장 적합한 database로 1990년대 가장 먼저 생성된 database인 Northwind를 사용할 것입니다.

원격지나 로컬에 MSSQL Server를 설치하고 Northwind Database를 아래 script file로 생성합니다. MSSQL에 관한 제사한 사항은 아래 link를 참고하시기 바랍니다.

[Server/SQL Server] - [MSSQL] MS SQL Server 다운로드 및 설치/설정

[MSSQL] MS SQL Server 다운로드및 설치/설정

해당 포스팅에서 설명하는 MS SQL Server는 2019 Developer Edtion입니다. 인터넷에서 아래 주소로 이동합니다. SQL Server 다운로드 | Microsoft SQL Server 다운로드 | Microsoft 지금 Microsoft SQL Server 다운로드를 시

lab.cliel.com

참고로 해당 Database의 전체 구조는 아래와 같습니다.

위 구조를 보면 다음과 같은 사항을 알 수 있습니다.

각 category는 고유한 식별자, 이름, 설명, 이미지를 갖고 있습니다.
각 product는 고유한 식별자, 이름, 단위 단가, 재고 단위 및 기타 field를 갖고 있습니다.
각 product는 category의 고유한 식별자를 통해 특정 category에 할당됩니다.
Category와 product의 관계는 각 category가 product를 0개 이상 가질 수 있는 1대다의 관계입니다.

northwnd.sql

1.01MB

2. EF Core 설정

EF Core를 사용하기 전 간단히 어떤 EF Core database 공급자를 선택할 수 있는지를 알아보도록 하겠습니다..

(1) ADO.NET database provider

Entity Framework이전에는 ADO.NET이 사용되었습니다. ADO.NET은 EF와 비교해 database를 대상으로한 더 단순하면서도 더 효휼적인 API인데 DbConnection, DbCommand, and DbReader같은 추상화 class와 SqlConnection과 SqlCommand같은 공급자별 구현을 제공합니다.

만약 application에 대한 database로 MS SQL Server를 사용하기로 했다면 SqlConnectionStringBuilder class를 통해 정확한 연결문자열을 사용해야 합니다. 해당 class에는 database 연결 문자열에 대한 모든 가능한 속성을 가지고 있고 이를 개별적으로 설정하여 완성된 연결문자열을 얻을 수 있습니다. 또한 비밀번호와 같은 민감한 정보의 경우에는 source code에 직접 작성하는 대신 환경변수나 별도의 관리 system에서 가져올 수 있도록 해야 합니다.

다만 SQLite라면 연결문자열은 굳이 SqlConnectionStringBuilder class를 사용하지 않아도 될만큼 간단하므로 굳이 class를 사용할 필요는 없습니다.

SQLite와 SQL Server에 대한 EF Core database 공급자는 항상 ADO.NET Library위에 구현되므로 본질적으로 ADO.NET보다 더 느립니다. 게다가 ADO.NET은 더 나은 성능을 위해 독립적으로 사용될 수 있지만 EF Core database 공급자는 ORM의 특징에 더 중심을 두기 때문에 성능면에서 ADO.NET이 유리할 수 있습니다.

또한 EF Core은 아직 AOT 배포를 지원하지 않으므로 만약 AOT를 사용하기로 했다면 EF Core대신 ADO.NET Library를 사용해야 합니다. 물론 EF Core team은 EF Core를 native AOT에 어떻게 지원할지를 살펴보고 있지만 시간적으로 꽤 걸릴것으로 보입니다.

ADO.NET에 관한 더 자세한 내용은 아래 link를 참고하시기 바랍니다.

Microsoft ADO.NET - ADO.NET Provider for SQL Server | Microsoft Learn

(2) EF Core database provider (공급자)

특정한 database의 data에 접근하기 위해서는 어떻게 database와 효휼적으로 data를 주고받을지를 알고 있는 class를 사용해야 합니다.

EF Core database 공급자는 이러한 일련의 class들을 말하며 특정한 database에 최적화되어 있습니다. 이러한 공급자들 중에는 심지어 현재 process의 memory에 data를 저장하는 공급자도 존재하며 특히 외부 system과의 충돌을 피할 수 있기 때문에 고성능 단위 test에서 사용하기 적합합니다.

아래표는 저장소별 NuGet package에 배포된 package를 나타내고 있습니다.

용도	NuGet Package
SQL Server 2012 부터	Microsoft.EntityFrameworkCore.SqlServer
SQLite 3.7 부터	Microsoft.EntityFrameworkCore.SQLite
In-memory	Microsoft.EntityFrameworkCore.InMemory
Azure Cosmos DB SQL API	Microsoft.EntityFrameworkCore.Cosmos
MySQL	MySQL.EntityFrameworkCore
Oracle DB 11.2	Oracle.EntityFrameworkCore
PostgreSQL	Npgsql.EntityFrameworkCore.PostgreSQL

필요하다면 하나의 project에서 다수의 EF Core database 공급자를 설치할 수 있으며 각 package는 공급자별 type뿐만 아니라 필요한 여러 공유 type을 포함하고 있습니다.

(3) Database 연결

Database연결을 위해서는 연결을 위한 연결문자열을 설정해야 합니다. 위에서 MSSQL Server를 설치했다는 가정하에 해당 server IP 및 login 계정 등의 정보를 묶어 하나의 연결문자열을 만들어줍니다.

(4) Northwind database context class 정의

Northwind class는 database를 표현하는 데 사용될 것입니다. 여기에 EF core를 사용하기 위해서 class는 DbContext로부터 상속받아야 합니다. 해당 class는 database와 어떻게 소통할지를 알고 있으며 data의 질의와 수정/삭제등의 조작을 위해 동적으로 SQL문을 생성합니다.

DbContext로 부터 파생된 class는 OnConfiguring라는 이름의 override 된 method를 갖게 되는데 해당 method를 통해 database 연결 문자열을 설정합니다.

우선은 project에서 MSSQL을 위한 EF Core 공급자인 Microsoft.EntityFrameworkCore.SqlServer NuGet package를 설치하고 Northwind.cs 이름의 class file을 추가합니다.

Northwind.cs file에서는 EF Core에 대한 namespace를 import한뒤 Northwind class를 정의하고 DbContext부터 상속받도록 합니다. 그리고 OnConfiguring method에서 MSSQL Server를 사용하기 위한 option builder를 아래와 같이 구성해 줍니다.

public class Northwind : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        string connection = "Server=localhost;user id=sa;password=!123;Database=Northwind;MultipleActiveResultSets=true";
        Console.WriteLine($"Connection: {connection}");
        optionsBuilder.UseSqlServer(connection);
    }
}

Program.cs에서는 기존의 문을 모두 삭제하고 사용하는 database 공급자를 확인할 수 있는 구문을 아래와 같이 작성합니다.

Northwind db = new();
Console.WriteLine($"Provider: {db.Database.ProviderName}");

예제를 실행하면 다음과 같은 결과를 표시할 것입니다. 이를 통해 database 연결문자열과 사용 중인 database 공급자를 확인할 수 있습니다.

3. EF Core model 정의

EF Core는 규칙과 annotation attribute의 결합 및 Fluent API 문을 사용하여 runtime에서 entity model을 build 합니다. 따라서 class상에서 수행되는 모든 동작은 나중에 자동적으로 실제 database에서 수행되는 동작으로 변환될 수 있습니다. entity class는 table의 구조를 나타내며 class의 instance는 table의 row로서 표현됩니다.

우선 예제를 통해 model을 정의하기 위한 3가지 방식을 검토하고 이러한 기술을 구현하는 몇 가지 class를 만들어볼 것입니다.

(1) model을 정의하기 위한 EF Core 규칙

예제로 작성될 code는 아래 규칙을 사용할 것입니다.

Table의 이름은 예를 들어 Products와 같이 DbContext class안에 있는 DbSet<T> 속성의 이름과 연결된다고 간주합니다.
Column의 이름은 예를 들어 ProductId와 같이 entity model class에 있는 속성의 이름과 연결된다고 간주합니다.
string .NET type은 database의 nvarchar type이 된다고 간주합니다.
int .NET type은 database의 int type이 된다고 간주합니다.
Primary key는 Id 혹은 ID이름의 속성이 된다고 간주합니다. 그런데 속성의 이름은 entity model class가 Product로 명명될 때 ProductId 혹은 ProductID로 명명될 수 있습니다. 해당 속성이 integer type 이거나 Guid type이라면 이것은 또한 IDENTITY column(insert시 자동적으로 값이 부여됨)이 될 수 있다고 간주합니다.

이외에 알아야 할 많은 규칙들이 존해하며 자신만의 것을 정의할 수도 있습니다. 이와 관련해서는 아래 link를 참고하시기 바랍니다.

Creating and Configuring a Model - EF Core | Microsoft Learn

Creating and Configuring a Model - EF Core

Overview of creating and configuring a Entity Framework Core model via Fluent API, Data Annotations and conventions.

learn.microsoft.com

(2) Model을 정의하기 위한 EF Core annotation attribute 사용하기

물론 위에서 언급한 규칙만으로는 database개체와 class를 완전히 연결시키에 충분하지 못할 수 있습니다. 이때 model을 더욱 database에 근접시키기 위한 가장 간단한 방법은 annotation attribute를 적용하는 것입니다.

아래 표는 일반적으로 사용되는 몇 가지 attribute를 나타내고 있습니다.

Attribute	Description
[Required]	값은 null이 될 수 없습니다. .NET 8에서는 DisallowAllDefaultValues 매개변수를 통해 예를 들어 int가 0이 되는 것처럼 type이 그에 따른 기본값이 되는것을 방지할 수 있습니다.
[StringLength(50)]	값은 50문자길이를 넘을 수 없습니다.
[Range(1, 10)]	값이 지정된 범위에 있도록 합니다. 이와 관련하여 .NET 8에서는 MinimumIsExclusive와 MaximumIsExclusive라는 매개변수가 존재합니다.
[RegularExpression(표현식)]	값은 지정한 정규표현식과 일치해야 합니다.
[Column(TypeName = "money", Name = "UnitPrice")]	Column의 이름(Name)과 Type(TypeName)을 지정합니다.

예를 들어 database에서 product name의 최대 길이는 40이며 값은 null일 수 없습니다. 이와 같은 사실은 어떻게 Products라는 table이 지정한 data type, key와 기타 제약사항을 가진 column과 함께 생성될지를 정의하는 DDL(Data Definition Language) 문을 통해 알 수 있는데

CREATE TABLE [dbo].[Products](
	[ProductId] [int] IDENTITY(1,1) NOT NULL,
	[ProductName] [nvarchar](40) NOT NULL,
	[SupplierId] [int] NULL,
	[CategoryId] [int] NULL,
	[QuantityPerUnit] [nvarchar](20) NULL,
	[UnitPrice] [money] NULL,
	[UnitsInStock] [smallint] NULL,
	[UnitsOnOrder] [smallint] NULL,
	[ReorderLevel] [smallint] NULL,
	[Discontinued] [bit] NOT NULL,
 CONSTRAINT [PK_Products] PRIMARY KEY CLUSTERED 
(
	[ProductId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO

...

이러한 사항을 Product class에 반영하려면 아래와 같이 attribute를 적용할 수 있습니다.

[Required]
[StringLength(40)]
public string ProductName { get; set; }

어떤 경우에는 .NET type과 database type사이를 연결시키는 데 사용가능한 attribute가 분명하지 않을 수 있습니다. 예를 들어 database에서 Products의 UnitPrice column type이 money인데 .NET은 money라는 type이 존재하지 않으므로 이런 경우에는 아래와 같이 data범위가 유사한 decimal을 대신 사용하고 Column attribute를 통해 database의 type을 명시합니다.

[Column(TypeName = "money")]
public decimal? UnitPrice { get; set; }

(3) Model을 정의하기 위한 EF Core Fluent API 사용하기

Model을 정의할 수 있는 또 다른 방법은 Fluent API를 사용하는 것입니다. API는 attribute대신 사용할 수 있으며 뿐만 아니라 속성 외에도 사용할 수 있습니다. 예를 들어 ProductName속성을 정의하기 위해 속성에 2개의 attribute를 적용하는 대신 동등한 Fluent API문을 database context class의 OnModelCreating method에 아래와 같이 작성할 수 있습니다.

modelBuilder.Entity<Product>()
 .Property(product => product.ProductName)
 .IsRequired()
 .HasMaxLength(40);

위와 같이 하면 entity model class를 단순하게 유지할 수 있습니다.

● Fluent API를 사용한 data 제공

Fluent API를 사용함으로써 생기는 또 다른 이점은 database를 채우기 위해 초기 data를 제공할 수 있다는 것입니다. EF Core는 반드시 실행되어야 하는 insert, update, delete와 같은 동작을 자동으로 실행합니다.

예를 들어 새로운 database에서 Product table은 최소 하나의 행을 가져야 한다면 HasData method를 아래와 같이 호출할 수 있습니다.

modelBuilder.Entity<Product>().HasData(new Product {
    ProductId = 1,
    ProductName = "Chai",
    UnitPrice = 8.99M
});

예제에서 사용할 model은 이미 data가 존재하는 database와 연결하게 될 것이므로 위와 같은 방법은 사용하지 않을 것입니다.

(4) Northwind table에 대한 EF Core model 구축

위에서 EF Core model을 정의하는 방법을 알게 되었으므로 이를 통해 Northwind database에 대한 2개 table을 표현하는 model을 만들 것입니다.

2개 entity class는 서로를 참조할 것이므로 compiler error를 피하기 위해 처음에는 어떠한 member도 없이 class를 만들 것입니다.

WorkingWithEFCore project에서 Category.cs와 Product.cs이름의 class file을 추가합니다. 그리고 Category.cs에서 Category class를 정의하고 Product.cs에서 Product class를 정의합니다.

namespace WorkingWithEFCore
{
    public class Category
    {
    }
}

namespace WorkingWithEFCore
{
    public class Product
    {
    }
}

● Category와 Product entity class정의하기

Entity model인 Category class는 Categories table의 row를 나타내는 데 사용될 것입니다. 이 table은 아래와 같이 4개의 column을 가지고 있습니다.

CREATE TABLE [dbo].[Categories](
	[CategoryId] [int] IDENTITY(1,1) NOT NULL,
	[CategoryName] [nvarchar](15) NOT NULL,
	[Description] [ntext] NULL,
	[Picture] [image] NULL,
 CONSTRAINT [PK_Categories] PRIMARY KEY CLUSTERED 
(
	[CategoryId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO

따라서 model을 정의하기 위한 다음의 규칙을 감안해야 합니다.

3~4개의 속성 (Picture column은 사용하지 않을 것입니다.)
Primary key
Products table과의 1:N 관계

Description column을 database type과 정확히 연결시키기 위해서는 string 속성에 Column attribute에 대한 적용이 필요합니다. 나중에는 Fluent API를 사용하여 CategoryName이 null일 수 없고 최대 15자로 제한됨을 정의할 것입니다.

Category entity model class를 아래와 같이 변경합니다.

using System.ComponentModel.DataAnnotations.Schema; // [Column] attribute

namespace WorkingWithEFCore
{
    public class Category
    {
        public Category()
        {
            // products를 Cateogry로 추가시킬 수 있도록 하기 위해서는 navigation 속성을 빈 collection으로 초기화 해야 합니다.
            Products = new HashSet<Product>();
        }

        //아래 속성은 database의 column과 일치합니다.
        public int CategoryId { get; set; }

        public string? CategoryName { get; set; }

        [Column(TypeName = "ntext")]
        public string? Description { get; set; }

        //Table간의 관계를 나타내기 위해 정의하는 navigation속성입니다.
        public virtual ICollection<Product> Products { get; set; }
    }
}

Product class도 역시 아래와 같이 변경합니다.

using System.ComponentModel.DataAnnotations; // [Required], [StringLength]
using System.ComponentModel.DataAnnotations.Schema; // [Column]

namespace WorkingWithEFCore
{
    public class Product
    {
        public int ProductId { get; set; } // primary key

        [Required]
        [StringLength(40)]
        public string ProductName { get; set; } = null!;

        [Column("UnitPrice", TypeName = "money")]
        public decimal? Cost { get; set; } // Column attribute를 적용함으로서 여기서 속성의 이름은 column의 이름으로 사용되지 않습니다.

        [Column("UnitsInStock")]
        public short? Stock { get; set; }

        public bool Discontinued { get; set; }

        // 이 2개의 속성은 Categories table에 대한 외래key를 정의합니다.
        public int CategoryId { get; set; }
        public virtual Category Category { get; set; } = null!;
    }
}

위 예제에서는 다음 사항에 주목합니다.

Product class는 Products table의 row를 표현하는 데 사용되며 10개 정도의 column을 가지고 있습니다.
Table로부터의 모든 column을 class의 속성으로 포함시킬 필요는 없습니다. 예제에서도 단지 ProductId, ProductName, UnitPrice, UnitsInStock, Discontinued, CategoryId에 대한 6개의 속성만을 일치시키고 있습니다.
속성으로 일치되지 않는 column은 class를 통해 읽거나 설정할 수 없습니다. 새로운 개체를 생성하는데 class를 사용한다면 table의 새로운 row에서 일치되지 않는 column은 NULL이 되거나 다른 기본값이 됩니다. 누락된 column이 생기는 경우 이들 column은 선택적이거나 database에서 기본값을 설정했거나 runtime에서 예외가 발생하는지를 확인해야 합니다. 지금 예제의 경우에 row는 이미 data값을 가지고 있으며 application에서 해당 값들을 읽을 필요가 없으므로 무시하기로 합니다.
예제에서 Cost속성처럼 Column의 이름과는 다른 이름으로 속성을 정의할 수도 있습니다. 이런 경우 속성에 [Column] attribute를 적용하고 여기에 UnitPrice처럼 column의 이름을 지정할 수 있습니다.
마지막 속성인 CategoryId는 각 product에서 부모 category와 일치시키는 데 사용되는 Category 속성과 연결됩니다.

2개의 entity를 연결시키는 2개의 속성인 Category.Products와 Product.Category는 둘 다 virtual로 수식되었습니다. 이는 EF Core가 lazy loading과 같이 추가 기능을 제공하기 위해 해당 속성을 상속하고 override 할 수 있도록 합니다.

(5) Northwind database context class에 table추가하기

DbContext로부터 파생된 class에서는 최소 하나의 DbSet<T> type에 대한 속성을 정의해야 합니다. 이 속성은 table을 의미합니다. EF Core에게 table의 가진 각 column이 어떤 것인지를 말해주기 위해 DbSet<T>속성은 generic을 사용하여 table의 row를 나타내는 class를 지정하고 해당 class는 column을 나타내는 속성을 가지게 됩니다.

DbContext 파생 class는 선택적으로 OnModelCreating이름의 override method를 가질 수 있습니다. 여기에 Fluent API를 class에 attribute를 적용하는 대신 작성할 수 있습니다.

Northwind class에서 Categories와 Products에 대한 2개의 table과 OnModelCreating method를 정의하는 문을 아래와 같이 추가합니다.

public class Northwind : DbContext
{
    public DbSet<Category>? Categories { get; set; }
    public DbSet<Product>? Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        string connection = "Server=localhost;user id=sa;password=!123;Database=Northwind;MultipleActiveResultSets=true";
        Console.WriteLine($"Connection: {connection}");
        optionsBuilder.UseSqlServer(connection);
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Fluent API를 사용해 CategoryName의 최대 길이를 15자로 제한합니다.
        // 이는 attribute를 적용하는 것으로도 가능합니다.
        modelBuilder.Entity<Category>()
        .Property(category => category.CategoryName)
        .IsRequired() // NOT NULL
        .HasMaxLength(15);
    }
}

(6) dotnet-ef 도구 설정

dotnet이라는 .NET CLI 도구는 EF Core사용에 유용한 기능으로 확장될 수 있습니다. 이 기능은 이전 model에서 새로운 model로 migration을 생성하고 적용하는 것과 같은 design-time작업을 수행할 수 있으며 기존 database로부터 code를 생성할 수도 있습니다.

dotnet ef 명령줄 도구는 자동적으로 설치되지 않으므로 global이나 local도구를 통해 package를 설치해야 합니다. 만약 해당 도구의 이전 version이 이미 설치된 경우라면 기존 version을 모두 삭제해야 합니다.

Terminal에서 우선 dotnet-ef가 global도구로 설치되어 있는지를 확인합니다.

dotnet tool list --global

위와 같이 이전 version이 이미 설치되어 있다면 아래와 같은 방식으로 도구를 제거할 수 있습니다.

dotnet tool uninstall --global dotnet-ef

예제의 화면상으로 version은 7.0.4인데 아래 명령을 통해 최신 version으로 update할 수 있습니다.

dotnet tool update --global dotnet-ef

설치는 uninstall대신 install을 사용합니다.

dotnet tool install --global dotnet-ef

필요하다면 OS별 지침에 따라 PATH 환경 변수에 dotnet tools directory를 추가할 수 있습니다.

(7) 기존 database를 사용한 Scaffolding model

기존 database에서 model을 표현하기 위한 class를 생성하는 것을 reverse engineering이라고 하며 이때 도구를 사용하는 처리를 Scaffolding이라고 합니다. 좋은 Scaffolding 도구는 자동적으로 생성된 class를 확장하고 확장된 class의 손실 없이 이들 class를 재생성할 수 있도록 합니다.

도구를 사용해 class를 재생성할 일이 없다고 하더라도 원하는 만큼 자동적으로 생성된 class에서 code를 자유롭게 변경할 수 있습니다. 도구에 의해 생성된 code는 그저 최상의 근사치일 뿐입니다.

도구를 사용하지 않고도 최상의 결과를 얻을 수 있다면 굳이 도구사용을 시도할 필요는 없습니다.

위에서 수동적으로 생성했던 것처럼 도구가 같은 model을 생성하는지 확인해 보도록 하겠습니다.

우선 WorkingWithEFCore project에서 최신의 Microsoft.EntityFrameworkCore.Design package를 설치하고 project를 build 합니다. 그런 뒤 terminal에서 WorkingWithEFCore folder(csproj project file이 있는)로 찾아 들어가고 아래 명령을 통해 AutoGenModels라는 folder에 Categories와 Products에 대한 model을 생성하도록 합니다.

dotnet ef dbcontext scaffold "Server=localhost;user id=sa;password=!123;Database=Northwind;TrustServerCertificate=true" Microsoft.EntityFrameworkCore.SqlServer --table Categories --table Products --output-dir AutoGenModels --namespace WorkingWithEFCore.AutoGen --data-annotations --context Northwind

위 명령줄에 사용된 것 중 server주소와 id 및 암호는 귀하의 server에 따라 다릅니다.

위 명령줄에 사용된 각 항목의 의미는 아래와 같습니다.

명령어는 dbcontext scaffold입니다.
연결문자열은 Server=localhost;user id=sa;password=!123;Database=Northwind;TrustServerCertificate=true 입니다.
Database 공급자는 Microsoft.EntityFrameworkCore.SqlServer 입니다.
Model로 생성하기 위한 table은 --table Categories --table Products로 지정합니다.
Model은 --output-dir AutoGenModels로 지정한 경로에 생성합니다.
Model의 namespace는 --namespace WorkingWithEFCore로 지정합니다.
Fluent API와 data annotation 사용을 위해 --data-annotations를 지정합니다.
context명칭을 --context Northwind로 지정합니다.

위 명령을 실행하면 정상적으로 처리되는 경우 아래와 같은 결과를 표시하게 됩니다.

생성이 완료되면 AutoGenModels folder를 열어 아래 3개 file이 생성되어 있는지를 확인합니다.

Northwind.cs
Product.cs
Category.cs

이 중에서 Category file을 열어 이전에 수동으로 작성한 file과의 차이점을 확인합니다.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Microsoft.EntityFrameworkCore;

namespace WorkingWithEFCore.AutoGen;

[Index("CategoryName", Name = "CategoryName")]
public partial class Category
{
    [Key]
    public int CategoryId { get; set; }

    [StringLength(15)]
    public string CategoryName { get; set; } = null!;

    [Column(TypeName = "ntext")]
    public string? Description { get; set; }

    [Column(TypeName = "image")]
    public byte[]? Picture { get; set; }

    [InverseProperty("Category")]
    public virtual ICollection<Product> Products { get; set; } = new List<Product>();
}

Entity class에는 [Index] attribute가 적용되어 있습니다. 이는 EF Core 5.0에서 도입된 것으로 index가 있어야 하는 속성을 나타냅니다. 이전 version에서는 단지 Fluent API를 통해서만 index를 정의할 수 있었습니다. 기존 database로의 작업에서는 이것이 필요하지 않았지만 code를 통해 초기 database를 재생성하고자 한다면 해당 정보가 필요할 것입니다.
Database에서 table의 이름은 Categories이지만 dotnet-ef 도구는 Humanizer third-party library를 사용하여 class의 이름을 Category로 단수화 하였습니다. 이는 단일 entity를 생성할 때 이름을 더욱 자연스럽게 만들기 위한 것입니다.
Entity class는 partial keyword를 사용하여 선언되었으므로 여기에 추가적인 code가 필요할 때 일치하는 partial class를 생성할 수 있습니다. 이를 통해 신규로 추가한 code의 손실 없이 도구를 사용해 entity class를 재생성할 수 있습니다.
CategoryId속성은 [Key] attribute가 적용되었습니다. 이는 해당 entity가 primary key임을 나타냅니다. 속성의 data type은 SQL Server에서의 int입니다.
Products 속성은 [InverseProperty] attribute를 사용하여 Product entity class상에서 Category 속성으로 외래 key의 관계를 정의하고 있습니다.

Product.cs file도 열어 이전에 수동적으로 생성한 것과의 차이를 확인합니다.

Northwind.cs file도 역시 이전에 수동적으로 생성한 것과의 차이를 확인합니다.

using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace WorkingWithEFCore.AutoGen;

public partial class Northwind : DbContext
{
    public Northwind()
    {
    }

    public Northwind(DbContextOptions<Northwind> options)
        : base(options)
    {
    }

    public virtual DbSet<Category> Categories { get; set; }

    public virtual DbSet<Product> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https://go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see http://go.microsoft.com/fwlink/?LinkId=723263.
        => optionsBuilder.UseSqlServer("Server=localhost;user id=sa;password=!123;Database=Northwind;TrustServerCertificate=true");

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Product>(entity =>
        {
            entity.Property(e => e.ReorderLevel).HasDefaultValueSql("((0))");
            entity.Property(e => e.UnitPrice).HasDefaultValueSql("((0))");
            entity.Property(e => e.UnitsInStock).HasDefaultValueSql("((0))");
            entity.Property(e => e.UnitsOnOrder).HasDefaultValueSql("((0))");

            entity.HasOne(d => d.Category).WithMany(p => p.Products).HasConstraintName("FK_Products_Categories");
        });

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}

Northwind data context class는 parital이므로 code를 확장하고 이후에 재생성할 수 있습니다.
위의 결과를 보면 2개의 생성자를 갖고 있음을 알 수 있는데 매개변수가 없는 기본 생성자와 options 매개변수를 가진 생성자가 그것입니다. 이는 runtime에서 연결문자열을 지정하고자 할 때 유용하게 사용될 수 있습니다.
위 결과에는 나타나지 않았지만 Categories와 Products table을 나타내는 2개의 DbSet<T>속성이 null-forgiving연산자값으로 설정될 수 있습니다. 이는 static compiler analysis가 compile time에서 경고가 발생되는 것을 방지하기 위함이며 runtime에서는 영향을 주지 않습니다.
위 결과에는 나타나지 않았지만 OnConfiguring method안에서는 options가 생성자에서 지정되지 않은 경우를 대비한 다음과 같은 code가 만들어질 수 있습니다.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    if (!optionsBuilder.IsConfigured)
    {
        //#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https://go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see http://go.microsoft.com/fwlink/?LinkId=723263.
        optionsBuilder.UseSqlServer("Server=localhost;user id=sa;password=!123;Database=Northwind;TrustServerCertificate=true");
    }
}

또한 연결 문자열에 민감한 정보를 hardcode 하지 말 것을 알리기 위한 compiler 경고를 포함하고 있습니다.
OnModelCreating method안에서는 Fluent API가 Product에 대한 entity class를 구성하기 위해 사용되었으며 OnModelCreatingPartial이름의 partial method를 호출합니다. 이를 통해 별도의 Fluent API configuration을 추가하기 위해 partial Northwind class를 따로 만들어 partial method method를 구현할 수 있고 model class를 재생성한다고 하더라도 추가한 code에는 영향을 주지 않을 수 있습니다.

(8) Reverse engineering template 사용자 정의하기

EF Core 7에서 새롭게 도입된 기능 중 하나이며 dotnet-ef scaffolding tool에 의해 자동적으로 생성되는 code를 개별적으로 정의할 수 있습니다. 해당 내용에 관해서는 아래 link를 참고하시기 바랍니다.

Custom Reverse Engineering Templates - EF Core | Microsoft Learn

Custom Reverse Engineering Templates - EF Core

Using T4 text templates to customize the scaffolded code when reverse engineering an Entity Framework Core model from a database

learn.microsoft.com

(9) 사전 규칙 model 구성하기

Entity type과 그들의 속성에 의존하는 규칙에서 model이 더 복잡해질수록 이들을 table과 column에 성공적으로 연결시키기는 더욱 어려워집니다. 따라서 model을 분석하고 생성하기 전에 스스로에 대한 규칙을 정의할 수 있다면 해당 기능은 매우 유용하게 사용될 수 있습니다.

예를 들어 모든 string 속성은 최대 문자길이가 기본적으로 50까지만 허용된다거나 사용자 interface를 구현하는 모든 속성은 연결에서 제외되어야 한다는 규칙을 정의하고자 한다면 다음과 같이 구현할 수 있습니다.

protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder.Properties<string>().HaveMaxLength(50);
    configurationBuilder.IgnoreAny<IUserInterface>();
}

4. EF Core model 질의하기

위 과정을 통해 Northwind database와 2개의 table에 연결되는 model을 만들게 되었습니다. 이로서 이제는 해당 table에서 data를 가져오기 위해 LINQ query를 작성할 수 있습니다. LINQ query를 작성하는 자세한 사항은 추후에 알아보기로 하고 이번예제에서는 간단하게만 사용해 보도록 하겠습니다.

project에 Queries.cs class file을 추가하고 그 안에 QueryingCategories method와 함께 partial Program class를 아래와 같이 정의합니다.

partial class Program
{
    static void QueryingCategories()
    {
        using (Northwind db = new())
        {
            IQueryable<Category>? categories = db.Categories?.Include(c => c.Products);

            if ((categories is null) || (!categories.Any()))
            {
                Console.WriteLine("Failed");
                return;
            }
                
            foreach (Category c in categories)
            {
                Console.WriteLine($"{c.CategoryName} has {c.Products.Count} products.");
            }
        }
    }
}

예제에서는 다음 사항에 주목합니다.

예제에서는 database를 관리할 Northwind class의 instance를 생성하고 있습니다. Database context instance는 작업단위 짧은 생명주기를 위해 설계되었으며 가능한 한 빨리 dispose 되어야 하므로 using문을 사용하였습니다.
관련된 projects를 포함한 전체 category를 위한 query를 생성합니다. 여기서 Include는 확장 method이며 사용을 위해서는 Microsoft.EntityFrameworkCore namespace를 import 해야 합니다.
가져온 category를 열거하면서 해당 category의 이름과 포함된 project의 수를 표시합니다.

if 문에서 || 사이의 순서는 중요한 부분입니다. categories가 null인지를 우선적으로 확인해야 하는데 만약 그 결과가 true라면 두 번째 문을 실행되지 않을 것이며 따라서 Any() member에 접근할 때 NullReferenceException 예외가 발생하지 않을 것입니다.

Program.cs에서는 Northwind instance를 생성하고 database provider의 이름을 출력하는 두 문을 주석처리하고 QueryingCategories method를 아래와 같이 호출합니다.

QueryingCategories();

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

(1) 포함된 entity filtering

EF Core 5에서는 filtered include를 도입하여 결과에서 반환된 entity를 filter 하기 위해 호출하는 Include method안에서 lambda 식을 명시할 수 있게 되었습니다.

Queries.cs에서 FilteredIncludes method를 아래와 같이 정의하고 아래 작업을 수행하는 문을 추가합니다.

Database를 다룰 Northwind class의 instance를 생성합니다.
사용자에게 재고의 최솟값을 입력받을 수 있도록 요청합니다.
재고가 입력된 값보다 같거나 그 보다 많은 product를 가진 Category를 가져오기 위해 query를 생성합니다.
Category와 Product를 열거하면서 각각에 대한 이름과 재고를 출력합니다.

static void FilteredIncludes()
{
    using (Northwind db = new())
    {
        string? input;
        int stock;

        do
        {
            Console.Write("Enter a minimum for units in stock: ");
            input = Console.ReadLine();

        } while (!int.TryParse(input, out stock));

        IQueryable<Category>? categories = db.Categories?.Include(c => c.Products.Where(p => p.Stock >= stock));

        if ((categories is null) || (!categories.Any()))
        {
            Console.WriteLine("No categories found.");
            return;
        }

        foreach (Category c in categories)
        {
            Console.WriteLine($"{c.CategoryName} has {c.Products.Count} products with a minimum of {stock} units in stock.");

            foreach (Product p in c.Products)
            {
                Console.WriteLine($"{p.ProductName} has {p.Stock} units in stock.");
            }
        }
    }
}

Program.cs에서 위의 FilteredIncludes method를 호출하면 다음과 같은 결과를 표시할 것입니다.

Windows 10 Fall Creators Update이전 Windows version에서 제공하는 console에는 하나의 제한사항이 있습니다. 기본적으로 console은 Unicode문자를 표시할 수 없습니다. 만약 예제를 실행하는 computer가 그렇다면 임시로 character set으로 알려진 code page를 console에서 아래 명령으로 Unicode UTF-8로 변경함으로써 해결할 수 있습니다.(예제를 실행시키기 전에)

chcp 65001

혹은 source에서 unicode문자를 표시하기전 아래 문을 넣어두면 정상적으로 unicode문자를 표시할 수 있게 됩니다.

Console.OutputEncoding = System.Text.Encoding.UTF8;

(2) Product filtering 하고 sorting 하기

Data를 filtering 하고 sorting 하기 위해 Queries.cs에서 QueryingProducts method를 정의하고 그 안에 아래의 동작을 위한 구문을 추가합니다.

Database를 다룰 Northwind class의 instance를 생성합니다.
사용자에게 products에 대한 가격을 입력하도록 요청합니다.
LINQ를 통해 입력한 가격보다 더 높은 products를 가져오는 query를 생성합니다.
결과를 순회하면서 ID, name, cost(예제에서의 단위는 dollar입니다.)와 재고를 표시하도록 합니다.

static void QueryingProducts()
{
    using (Northwind db = new())
    {
        string? input;
        decimal price;
        do
        {
            Console.Write("Enter a product price: ");
            input = Console.ReadLine();
        } while (!decimal.TryParse(input, out price));

		IQueryable<Product>? products = db.Products?.Where(product => product.Cost > price).OrderByDescending(product => product.Cost);

		if ((products is null) || (!products.Any()))
		{
			Console.Write("No products found.");
			return;
		}

		foreach (Product p in products)
		{
			Console.WriteLine("{0}: {1} costs {2:$#,##0.00} and has {3} in stock.", p.ProductId, p.ProductName, p.Cost, p.Stock);
		}
	}
}

예제에서의 '!products.Any()'는 'products.Count() == 0'과 같이 count를 확인하는 것보다 더 효휼적으로 작동합니다.

Program.cs에서 QueryingProducts method를 호출하면 사용자에게 price입력을 요청하고 그 결과를 다음과 같이 표시할 것입니다.

만약 위 입력요청에서 price를 500과 같이 입력하면 결과는 다음처음 달라질 수 있습니다.

(3) 생성된 SQL 확인하기

위와 같은 상황에서 C# code가 실제 어떤 SQL문을 생성하는지 궁금할 수 있습니다. EF Core 5부터는 생성된 SQL문을 보기 위한 빠르고 편리한 다음 방법을 도입하였습니다.

FilteredIncludes method에서 foreach문을 사용해 query를 열거하기 전에 생성된 SQL문을 출력하는 다음 문을 추가합니다.

if ((categories is null) || (!categories.Any()))
{
    Console.WriteLine("No categories found.");
    return;
}

Console.WriteLine($"ToQueryString: {categories.ToQueryString()}");

예제를 실행하면 다음과 같이 생성된 SQL문을 확인해 볼 수 있습니다.

(4) EF Core Logging

EF Core와 database간상호작용을 살펴보기 위해 logging을 사용할 수 있습니다. 이때 logging은 console이나 Debug, Trace 또는 file이 될 수 있습니다.

기본적으로 EF Core logging은 민감한 data는 제외합니다. 만약 이러한 data도 모두 포함하고자 한다면(특히 개발과정 동안에는) EnableSensitiveDataLogging method를 호출할 수 있습니다. 반대로 완성된 Application을 출시하는 경우 해당 기능을 disable 해야 합니다.

Northwind.cs의 OnConfiguring method아래에 console로의 log를 위한 아래 문을 추가합니다.

optionsBuilder.UseSqlServer(connection);
optionsBuilder.LogTo(Console.WriteLine).EnableSensitiveDataLogging();

LogTo는 Action<string> delegate를 필요로 하며 EF core는 각 log message에 대한 문자열값을 전달함으로써 해당 delegate를 호출할 것입니다. 따라서 위 예제처럼 Console class의 WriteLine method를 전달하는 것은 logger에게 각 method를 console에 쓰도록 하는 것입니다.

예제를 실행하면 다음과 같이 각 log를 상세하게 표시할 것입니다.

Log는 사용 중인 database 공급자와 code 편집기 및 향후 EF Core의 개선점에 따라 달라질 수 있습니다. 일반적으로 연결을 열거나 명령 실행과 같은 다른 event마다 다음과 같이 다른 event ID를 가지고 있습니다.

RelationalEventId.ConnectionOpening[20000] : 원격 server 혹은 file 경로를 포함
RelationalEventId.ConnectionOpened[20001] : 원격 server 혹은 file 경로를 포함
RelationalEventId.CommandExecuting[20100] : 실행하는 SQL문 포함

● 공급자별 값을 통한 log filtering

event ID값과 그 의미는 EF Core 공급자에 따라 달라질 수 있습니다. LINQ query가 SQL 문으로 어떻게 변환되고 실행되는지를 알고자 한다면 20100의 Id값을 가진 event ID를 확인하면 됩니다.

이를 위해 아래에서와 같이 Northwind.cs에서 LogTo method를 변경하여 Id가 20100인 event만 출력하도록 합니다.

optionsBuilder.LogTo(Console.WriteLine, new[] { RelationalEventId.CommandExecuting }).EnableSensitiveDataLogging();

예제를 실행하면 다음과 같이 log 된 SQL문을 확인할 수 있습니다.

● Query tag를 통한 logging

LINQ query를 logging 할 때 복잡한 상황에서 log message를 서로 관련시키기가 어려울 수 있습니다. EF Core 2.2에서는 query tag 기능을 도입하여 SQL 문을 log에 추가시키기 한결 편리해졌습니다.

아래와 같이 TagWith method를 사용해 LINQ query에 적용합니다.

IQueryable<Category>? categories = db.Categories?.TagWith("*****Category*****").Include(c => c.Products.Where(p => p.Stock >= stock));

위와 같이 하면 log에 SQL comment를 다음과 같이 추가하게 됩니다.

(5) Like를 사용한 pattern matching

EF Core에서는 pattern matching을 위한 Like와 같이 일반적인 SQL문을 지원하고 있습니다.

Queries.cs에서 다음과 같이 QueryingWithLike이름의 method를 추가합니다.

static void QueryingWithLike()
{
    using (Northwind db = new())
    {
        Console.Write("Enter part of a product name: ");
        string? input = Console.ReadLine();

        if (string.IsNullOrWhiteSpace(input))
        {
            Console.WriteLine("You did not enter part of a product name.");
            return;
        }

        IQueryable<Product>? products = db.Products?.Where(p => EF.Functions.Like(p.ProductName, $"%{input}%"));

        if ((products is null) || (!products.Any()))
        {
            Console.WriteLine("No products found.");
            return;
        }

        foreach (Product p in products)
        {
            Console.WriteLine("{0} has {1} units in stock. Discontinued? {2}", p.ProductName, p.Stock, p.Discontinued);
        }
    }
}

위 예제에서는 logging을 사용하고 있으며 사용자에게 product에 대한 이름 중 일부에 대한 입력을 요구하고 있습니다. 사용자가 입력을 완료하면 EF.Functions.Like method를 사용해 입력된 내용을 ProductName 속성으로 검색을 시도합니다.

여기서 일치하는 product가 존재하면 각 product에 대한 이름과 재고 그리고 생산여부등을 출력합니다.

Program.cs에서 기존의 method 호출을 주석처리하고 위에서 추가한 QueryingWithLike method를 호출하도록 합니다. 그런 뒤 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

(6) Query를 통한 임의 숫자 생성하기

EF Core 6에서는 한 가지 유용한 기능인 EF.Functions.Random을 도입하여 0과 1 사이에 배타적인 의사난수를 반환하는 database기능과 연결할 수 있습니다. 예를 들어 table에서 임의의 row를 선택하기 위해 전체 row 수에서 임의의 숫자를 곱할 수 있습니다.

Queries.cs에서 GetRandomProduct이름의 method를 아래와 같이 추가합니다.

static void GetRandomProduct()
{
    using (Northwind db = new())
    {
        int? rowCount = db.Products?.Count();

        if (rowCount == null)
        {
            Console.WriteLine("Products table is empty.");
            return;
        }

        Product? p = db.Products?.FirstOrDefault(p => p.ProductId == (int)(EF.Functions.Random() * rowCount));

        if (p == null)
        {
            Console.WriteLine("Product not found.");
            return;
        }

        Console.WriteLine($"Random product: {p.ProductId} {p.ProductName}");
    }
}

Program.cs에서 GetRandomProduct method를 호출하면 아래와 같은 결과를 표시할 것입니다.

(7) Global filter 정의하기

Northwind의 products, 즉 제품은 단종될 수 있을 것입니다. 따라서 단종된 product는 결과에 반영되지 않도록 하는 것이 합리적일 수 있는데 products를 조회하는 모든 곳에 where를 사용하여 이러한 사항을 filtering 하기보다는 global로 filter를 적용하여 where를 사용하지 않고 해당 filtering을 products를 조회하는 모든 곳에 적용할 수 있습니다.

Northwind.cs의 OnModelCreating method아래에 아래와 같이 단종된(discontinued) product를 제거하는 global filter를 추가합니다.

modelBuilder.Entity<Category>()
            .Property(category => category.CategoryName)
            .IsRequired() // NOT NULL
            .HasMaxLength(15);
modelBuilder.Entity<Product>().HasQueryFilter(p => !p.Discontinued);

Program.cs에서 QueryingWithLike method를 호출하고 product name으로 che를 입력합니다. 다음 결과에서 보듯 'Chef Anton’s Gumbo Mix'는 반영되지 않았습니다. 생성된 SQL문을 확인해 보면 Discontinued column에 대한 filter를 포함하고 있기 때문입니다.

5. EF Core의 loading pattern

EF Core에서 일반적으로 사용되는 3가지 loading pattern이 존재합니다.

Eager loading : 사전 data load
Lazy loading : 필요하기 직전에 자동적으로 data load
Explicit loading : 수동으로 data load

(1) 확장 method 포함을 사용한 eager loading

QueryingCategories method에서 현재 code는 각 category를 순회하기 위해 Categories 속성을 사용하며 category name과 category에 속한 products 수를 출력하고 있습니다.

이것은 이전에 query를 작성할 때 관련된 products에 대한 Include method를 호출함으로써 eager loading를 사용했기 때문입니다.

이때 Include를 사용하지 않으면 어떤 현상이 발생하는지 확인해 보겠습니다.

QueryingCategories method에서 아래와 같이 Include method의 호출 부분을 주석처리합니다.

IQueryable<Category>? categories = db.Categories;//?.Include(c => c.Products);

Program.cs에서 QueryingCategories method를 호출하면 다음과 같은 결과가 표시됩니다.

foreach안에서 각 item은 Products 속성을 갖고 있는 Category class의 instance인데 Products 속성은 category에서의 products list를 의미합니다. 위 예제에서 query는 단지 Categories table만을 select 하고 있으므로 해당 속성은 각 category에서 비어있게 됩니다.

(2) Lazy loading 사용

Lazy loading은 EF Core 2.1에서 도입된 것으로 누락된 관계 data를 자동으로 load 할 수 있습니다. lazy loading을 사용하기 위해서는 우선 proxy를 위한 NuGet package를 참조해야 하며 해당 proxy사용을 위한 lazy loading을 구성해야 합니다.

Visual Studio 2022에서 Microsoft.EntityFrameworkCore.Proxies NuGet package를 찾아 이를 참조합니다. 그리고 Northwind.cs의 OnConfiguring method아래에 UseLazyLoadingProxies 확장 method를 호출하도록 합니다.

optionsBuilder.LogTo(Console.WriteLine, new[] { RelationalEventId.CommandExecuting }).EnableSensitiveDataLogging();
optionsBuilder.UseLazyLoadingProxies();

이렇게 하면 loop를 열거하면서 Products 속성을 읽으려고 시도할 때마다 lazy loading proxy는 data가 load 되었는지를 확인합니다. 그렇지 않다면 SELECT문을 실행하여 현재 category에 대한 products만을 load 하게 됩니다. 다시 말해 속성에 대한 접근이 있으면 그때 data를 database server에서 가져와야 할지를 판단하고 필요하면 그렇게 한다는 것입니다. 이렇게 되면 정확한 count를 출력에 반환할 수 있습니다.

예제를 다시 실행하면 이번에는 정확한 product count가 표시될 것입니다. 다만 모든 data를 가져오기 위해 database server와 여러 번 통신해야 하는 과정이 필요하다는 단점이 있습니다. 예를 들어 모든 categories를 가져온 다음 첫 번째 category인 Beverages에 대한 products를 가져오기 위해 아래와 같이 두 번의 SQL 명령을 실행하고 있습니다.

(3) Load method를 사용해 명시적으로 entity loading 하기

명시적 loading은 lazy loading과 비슷하지만 관계 data가 load 되는 것과 언제 load 될지를 정확히 제어한다는 차이가 있습니다. lazy loading은 해당 속성에 접근하면 처리되지만 explicit loading은 처리시점과 대상을 개발자가 결정합니다.

Queries.cs에서 우선 ChangeTracking namespace를 import 합니다. 해당 namespace는 관계 entity를 수동적으로 load 하도록 하는 CollectionEntry class를 사용하기 위한 것입니다.

using Microsoft.EntityFrameworkCore.ChangeTracking;

QueryingCategories안에서 아래와 같이 lazy loading을 위해 변경한 부분을 주석처리한 다음 사용자에게 eager loading과 explicit loading 중 어느 것을 사용할지를 선택하도록 요청하는 문을 아래와 같이 추가합니다.

IQueryable<Category>? categories;// = db.Categories;//?.Include(c => c.Products);

db.ChangeTracker.LazyLoadingEnabled = false;

Console.Write("Enable eager loading? (Y/N): ");
bool eagerLoading = (Console.ReadKey(intercept: true).Key == ConsoleKey.Y);
bool explicitLoading = false;
Console.WriteLine();

if (eagerLoading)
{
    categories = db.Categories?.Include(c => c.Products);
}
else
{
    categories = db.Categories;
    Console.Write("Enable explicit loading? (Y/N): ");
    explicitLoading = (Console.ReadKey(intercept: true).Key == ConsoleKey.Y);
    Console.WriteLine();
}

foreach loop안에서는 WriteLine method를 호출하기 전 explicit loading을 사용하는지 확인하고 그렇다면 사용자에게 명시적으로 각각의 개별 category를 명시적으로 load 할지를 결정하도록 합니다.

예제를 실행하고 eager loading를 비활성화하기 위해 N을 누릅니다. 그런 다음 explicit loading을 위해 Y를 누르고 각 category에서 products를 load 할지에 대한 선택을 진행합니다.

위 예제에서는 처음 2건에 대한 products만을 load 하도록 하였습니다.

사용하고자 하는 loading pattern을 선택할 때는 주의해야 합니다. loading pattern에 관해서는 아래 link를 참고하시기 바랍니다.

(4) Entity 추적 제어

우선은 entity의 identity resolution을 정의하는 것으로 시작해야 합니다. EF Core는 entity instance에서 각각의 고유한 primary key값을 읽음으로서 resolve를 수행하는데 이런 과정을 통해 entity 혹은 entity 사이의 관계를 식별하는데 모호함을 제거할 수 있게 됩니다.

EF Core는 기본적으로 appliction이 실행되는 memory안에서 entity를 추적합니다. 따라서 새로운 entity를 추가하거나 수정하거나 삭제하는등의 변경사항이 발생하면 꼭 SaveChanges method를 호출하여 해당 변경사항이 실제 database에 반영되도록 해야 합니다.

EF Core는 key가 database에서 entity를 식별할 수 있는 고유값에 해당하므로 이를 통해서만 entity를 추적할 수 있습니다.

Northwind database에서 Customer table을 보면 여기에 다음과 같은 고객 정보가 존재함을 알 수 있습니다.

CustomerId: ALFKI
CompanyName: Alfreds Futterkiste
Country:Germany
Phone: 030-0074321

만약 해당 data context에서 Germany에 해당하는 모든 customer를 불러오는 query를 실행한 뒤 같은 data context안에서 이름이 A로 시작하는 모든 customer를 불러오는 또 다른 query를 실행한다면, 해당 context안에서 특정 customer가 이미 존재한다면 성능향상을 이는 다시 load하지 않습니다.

하지만 이전에 위 설명과 같은 2개의 query를 실행하는 사이 customer의 telephone정보가 update됐다면 data context에서 추적된 entity는 변경된 telephone 정보를 반영하지 않게 되므로 이를 최신의 customer정보로 인정할 수 없게 됩니다.

만약 지역적 변경사항에 대한 추적이 필요하지 않거나 매번 query를 실행할때 마다 최신의 data값을 가진 entity의 instance를 새롭게 load하고자 한다면 추적기능 자체를 비활성화할 수 있습니다.

각각의 query에서 추적을 끄려면 해당 query에서 AsNoTracking method를 호출하거나

var products = db.Products
 .AsNoTracking()
 .Where(p => p.UnitPrice > price)
 .Select(p => new { p.ProductId, p.ProductName, p.UnitPrice });

data context의 instance자체에서 추적을 끄려면 ChangeTracker의 QueryTrackingBehavior설정을 아래와 같이 NoTracking으로 설정해 주면 됩니다.

db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

혹은 각각의 query에서 추적을 끄지만 identity resolution을 그대로 유지하고자 한다면 AsNoTrackingWithIdentityResolution method를 대신 호출합니다.

var products = db.Products
 .AsNoTrackingWithIdentityResolution()
 .Where(p => p.UnitPrice > price)
 .Select(p => new { p.ProductId, p.ProductName, p.UnitPrice });

물론 같은 원리로 data context의 instance에도 같은 설정을 적용할 수 있습니다.

db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTrackingWithIdentityResolution;

모든 새로운 data context에서 일관되게 같은 설정을 적용해야 한다면 OnConfiguring method에서 UseQueryTrackingBehavior method를 호출해 줍니다.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseSqlServer(connectionString).UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
}

● 추적이 발생하는 3가지 사례

첫번째로 identity resolution을 통한 default tracking을 사용하는 경우 입니다. Entity가 일단 data context로 load되면 실제 database에 대한 변경사항은 적용되지 않으며 지역적으로 하나의 복사본이 생성됩니다. Entity는 지역적으로 변경된 사항을 추적하고 SaveChanges method를 호출하여 database를 update합니다.

동작	Entity	Database Table Row
불러오기	A	A
Database 변경	A	B
Entity 변경	C	B
SaveChanges	C	C

두번째는 변경사항에 대한 추적을 하지 않고 identity resolution을 사용하지 않는 경우 입니다. 모든 질의는 다른 table row의 instance를 load하며 변경과 중복을 허용합니다.

동작	Entity	Database Table Row
불러오기	A	A
Database 변경	A	B
불러오기	A B	B
SaveChanges	A B	B

마지막 세번째는 변경사항에 대한 추적을 하지 않으면서 identity resolution을 사용하는 경우입니다. 일단 entity가 data context로 load되고 나면 Database에 대한 변경사항은 적용되지 않으며 오로지 복사본만 존재합니다. 변경사항을 추적하지 않으므로 두번째 경우와 마찬가지로 SaveChanges method는 어떠한 동작도 수행하지 않습니다.

동작	Entity	Database Table Row
불러오기	A	A
Database 변경	A	B
불러오기	A	B
Entity 변경	C	B
SaveChanges	C	B

● 추적없는 query에 대한 Lazy loading

EF Core 7과 그 이전에서는 추적을 사용하지 않도록 설정하면 lazy loading pattern은 사용할 수 없었고 만약 그러한 시도를 하게 되면 System.InvalidOperationException예외가 발생합니다.

그러나 EF Core 8에 들어서 추적을 활성화하지 않더라도 entity에 대한 lazy loading을 지원하기 시작했습니다.

private static void LazyLoadingWithNoTracking()
{
    using NorthwindDb db = new();
 
    IQueryable<Product>? products = db.Products?.AsNoTracking();
    
    if (products is null || !products.Any())
    {
        Console.WriteLine("No Products.");
        return;
    }

    foreach (Product p in products)
    {
        Console.WriteLine("{0} is in category {1}.", p.ProductName, p.Category.CategoryName);
    }
}

위 예제는 Product에 대한 query에서 추적을 사용하지 않도록 하고 있으며 Product를 열거할때 lazy loading을 사용하여 관련된 Category이름을 가져오도록 하고 있습니다. EF Core 7이나 6에서 위 code를 실행하면 예외가 발생합니다.

● AsNoTracking에 대한 오해.

인터넷의 여러 community에서는 간혹 AsNoTracking이 성능향상을 위한 좋은 선택임을 강조하는 경우가 있습니다. 하지만 상상해 보십시오. 수십, 수백개의 entity를 가져오는 query를 AsNoTracking으로 실행한 뒤 다시 같은 data context안에서 동일한 query를 수행하게 되면 memory에는 수백개의 중복된 entity가 저장되는 상황을 맞이하게 될 것입니다.

이는 memory낭비를 초래하며 당연히 성능에도 부정적인 영향을 줄 수 밖에 없을 것입니다. 다시 말해 성능향상을 위해 AsNoTracking을 호출하라는 조언은 모든 상황에서 해당되지 않을 수 있으므로 주의가 필요합니다.

6. EF Core를 사용한 data변경

EF Core를 사용해 entity를 Insert, update, delete 하는 데는 큰 어려움이 없습니다.

DbContext는 변화에 대한 추적관리를 자동으로 하게 되므로 local entity에 새로운 entity를 추가하거나 기존 entity를 수정하거나 혹은 삭제하는 것을 포함해 추적된 여러 변화를 가질 수 있습니다.

그리고 이러한 변경된 사항들을 database에 반영하려면 SaveChanges method를 호출하기만 하면 되고 경우에 따라 성공적으로 변경된 entity의 수가 반환될 것입니다.

(1) Entity Insert

Table에 새로운 row를 추가해 보기 위해 Modifications.cs file을 추가하고 여기에 가장 비싼 순으로 정렬된 각 product에 대한 ID, name, cost, stock, 그리고 discontinued속성을 출력하고 method에 선택적으로 전달된 int값의 array와 일치하는 모든 것을 가종하는 ListProducts이름의 method와 함께 partial Program class를 생성합니다.

partial class Program
{
    static void ListProducts(int[]? productIdsToHighlight = null)
    {
        using (Northwind db = new())
        {
            if ((db.Products is null) || (!db.Products.Any()))
            {
                Console.WriteLine("There are no products.");
                return;
            }

            Console.WriteLine("| {0,-3} | {1,-35} | {2,8} | {3,5} | {4} |", "Id", "Product Name", "Cost", "Stock", "Disc.");

            foreach (Product p in db.Products)
            {
                ConsoleColor previousColor = System.Console.ForegroundColor;

                if ((productIdsToHighlight is not null) && productIdsToHighlight.Contains(p.ProductId))
                {
                    System.Console.ForegroundColor = ConsoleColor.Green;
                }

                Console.WriteLine("| {0:000} | {1,-35} | {2,8:$#,##0.00} | {3,5} | {4} |", p.ProductId, p.ProductName, p.Cost, p.Stock, p.Discontinued);

                System.Console.ForegroundColor = previousColor;
            }
        }
    }
}

위 예제에서 '{숫자1, 숫자2}'는 숫자 1번째의 인수를 숫자 2만큼의 문자열 넓이로 정렬함을 의미합니다. 이때 숫자 2가 -면 왼쪽 정렬을 양수이면 오른쪽 정렬입니다.

이어서 Modifications.cs에 AddProduct method를 아래와 같이 추가합니다.

static (int affected, int productId) AddProduct(int categoryId, string productName, decimal? price)
{
    using (Northwind db = new())
    {
        if (db.Products is null) return (0, 0);

        Product p = new()
        {
            CategoryId = categoryId,
            ProductName = productName,
            Cost = price,
            Stock = 72
        };

        // Insert 추가
        EntityEntry<Product> entity = db.Products.Add(p);
        Console.WriteLine($"State: {entity.State}, ProductId: {p.ProductId}");

        // 변경된 추적사항을 database에 반영
        int affected = db.SaveChanges();
        Console.WriteLine($"State: {entity.State}, ProductId: {p.ProductId}");

        return (affected, p.ProductId);
    }
}

Program.cs에서는 기존의 문을 모두 주석처리하고 위의 AddProduct와 ListProducts를 호출하는 문을 아래와 같이 추가합니다.

var resultAdd = AddProduct(categoryId: 6, productName: "Apple2 Computer", price: 1200M);

if (resultAdd.affected == 1)
{
    Console.WriteLine($"Add product successful with ID: {resultAdd.productId}.");
}
                         
ListProducts(productIdsToHighlight: new[] { resultAdd.productId });

예제를 실행하면 새로운 product를 추가한 다음과 같은 결과를 표시할 것입니다.

새로운 product가 처음 memory에 생성되고 EF Core change tracker에 의해 추적되기 시작하면 Added 상태와 0인 ID를 가지게 됩니다. 그런 후 SaveChanges가 호출되면 상태는 UnChanged로 바뀌게 되고 ID값은 78로 database에 의해 할당됩니다.

(2) Entity Update

기존에 존재하는 table의 row를 변경하기 위해 update 할 product를 product name의 시작을 지정하여 검색한 다음 가장 먼저 일치하는 것만 반환하도록 하는 예제를 작성할 것입니다.(실제로는 ProductId와 같이 고유한 식별자를 사용해 update할 product를 지정하는 것이 일반적입니다.)

Product를 추가할 때는 실제 어떤 product ID가 할당될지 알 수 없습니다. 다만 현재 Northwind database에 'Apple2'로 시작하는 product가 없다는 것만 알고 있을 뿐입니다. name을 사용해 update 할 product를 찾으면 이전에 추가한 product의 ID를 알아내야 하는 것을 피할 수 있습니다. 물론 database에는 77까지의 ID가 존재하므로 새로운 product의 ID가 78이 될 수 있음을 유추할 수 있지만 product를 추가한 뒤 삭제한다고 해도 다음 product의 ID는 79가 될 수 있으며 이때부터 번호순서 예상에 맞지 않을 수 있습니다.

Modifications.cs에서는 name이 지정된 값으로 시작하는 product에 대해 $20과 같이 지정한 만큼 price를 증가시키는 method를 추가합니다.

static (int affected, int productId) IncreaseProductPrice(string productNameStartsWith, decimal amount)
{
    using (Northwind db = new())
    {
        if (db.Products is null) return (0, 0);

        Product updateProduct = db.Products.First(p => p.ProductName.StartsWith(productNameStartsWith));

        updateProduct.Cost += amount;

        int affected = db.SaveChanges();

        return (affected, updateProduct.ProductId);
    }
}

Program.cs에서는 IncreaseProductPrice method를 호출한 다음 다시 ListProducts method를 호출하는 문을 아래와 같이 추가합니다.

var resultUpdate = IncreaseProductPrice(productNameStartsWith: "Apple", amount: 30M);

if (resultUpdate.affected == 1)
{
    Console.WriteLine("Increase price success for ID: {resultUpdate.productId}.");
}

ListProducts(productIdsToHighlight: new[] { resultUpdate.productId });

예제를 실행하면 다음과 같은 결과를 표시할 것입니다. 이전에 추가한 'Apple2 Computer'에 대한 price가 $30만큼 증가되었습니다.

(3) Entity Delete

각각의 entity들은 Remove method를 사용함으로써 삭제할 수 있습니다. RemoveRange는 여러 entity를 제거하고자 할 때 더 적합한 method입니다.

Modifications.cs에서 지정한 값으로 시작하는 모든 product를 삭제하는 method를 아래와 같이 추가합니다.

static int DeleteProducts(string productNameStartsWith)
{
    using (Northwind db = new())
    {
        IQueryable<Product>? products = db.Products?.Where(p => p.ProductName.StartsWith(productNameStartsWith));

        if ((products is null) || (!products.Any()))
        {
            Console.WriteLine("No products found to delete.");

            return 0;
        }
        else
        {
            if (db.Products is null) return 0;
            db.Products.RemoveRange(products);
        }

        int affected = db.SaveChanges();
        return affected;
    }
}

Program.cs에서는 아래와 같이 DeleteProducts method를 호출하는 문을 추가합니다.

Console.WriteLine("About to delete all products whose name starts with Apple.");
Console.Write("Press Enter to continue or any other key to exit: ");

if (Console.ReadKey(intercept: true).Key == ConsoleKey.Enter)
{
    int deleted = DeleteProducts(productNameStartsWith: "Apple");

    Console.WriteLine($"{deleted} product(s) were deleted.");
}
else
{
    Console.WriteLine("Delete was canceled.");
}

예제를 실행하고 Enter key를 누르면 다음과 같은 결과를 표시하게 됩니다.

만약 Apple로 시작하는 product가 여러 건이라면 해당되는 모든 product는 삭제될 것입니다.

(4) 더욱 효율적인 Update와 Delete

지금까지의 방법은 EF Core를 사용한 비교적 전통적인 data수정 방식으로 과정을 다음과 같이 요약할 수 있습니다.

Database context를 생성합니다. (변경추적은 기본으로 사용됩니다.)
Insert를 위해 entity class에 대한 instance를 생성하고 Add method의 매개변수로 collection을 db.Products.Add(product) 처럼 전달합니다.
Update를 위해서는 update 하고자 하는 entity를 가져와 이들에 대한 속성을 변경합니다.
Delete를 위해서는 delete 하고자 하는 entity를 가져와 Remove 또는 RemoveRange method의 매개변수로 db.Products.Remove(product) 처럼 전달합니다.
database context의 SaveChanges method를 호출하면 change tracker는 insert, update, delete수행에 필요한 SQL 문을 생성해 실행하고 적용된 entity의 수를 반환합니다.

EF Core 7에서는 사전에 load 해야 할 entity와 이들에 대한 변경점을 필요로 하지 않음으로써 더 효휼적으로 update와 delete를 수행할 수 있는 ExecuteDelete와 ExecuteUpdate(Async method도 동일함) 2개의 method를 도입하였습니다. 이들은 LINQ query상에서 호출되어 query 결과에 대한 entity에 영향을 주게 됩니다. query가 entity를 검색하는 데 사용되지 않으므로 어떠한 entity도 data context로 load 되지 않습니다.

예를 들어 table의 모든 row를 삭제하고자 한다면 ExecuteDelete 혹은 ExecuteDeleteAsync method를 모든 DbSet속성으로 아래와 같이 호출합니다.

await db.Products.ExecuteDeleteAsync();

위의 code는 database에서 다음과 같은 SQL문을 실행할 것입니다.

DELETE FROM Products

만약 50보다 더 높은 UnitPrice를 가진 product를 삭제하고자 한다면 아래와 같이 LINQ를 작성할 수 있습니다.

await db.Products.Where(product => product.Cost > 50).ExecuteDeleteAsync();

위의 code는 database에서 다음과 같은 SQL문을 실행할 것입니다.

DELETE FROM Products p WHERE p.Cost > 50

ExecuteUpdate와 ExecuteDelete는 단지 단일 table상에서만 동작할 수 있습니다. 만약 다수의 table에 걸친 꽤 복잡한 LINQ query를 작성했다고 하더라도 단일 table에서만 update나 delete가 수행됩니다.

또 다른 예로 Discontinued가 false인 모든 product의 UintPrice값을 10% 인상으로 update 하고자 한다면 LINQ는 아래와 같이 작성될 수 있습니다.

await db.Products.Where(product => !product.Discontinued).ExecuteUpdateAsync(s => s.SetProperty(
p => p.Cost, //update할 속성 선택
p => p.Cost * 0.1m)); //속성 update

위 예제와 같은 경우 하나의 LINQ안에서 다수의 속성을 update 하기 위해 같은 query에서 다수의 SetProperty를 호출해 연

결할 수 있습니다.

Modifications.cs에서 ExecuteUpdate를 사용해 name이 지정한 값으로 시작하는 모든 product를 update 하는 method를 아래와 같이 추가합니다.

static (int affected, int[]? productIds) IncreaseProductPricesBetter(string productNameStartsWith, decimal amount)
{
    using (Northwind db = new())
    {
        if (db.Products is null)
            return (0, null);

        IQueryable<Product>? products = db.Products.Where(p => p.ProductName.StartsWith(productNameStartsWith));

        int affected = products.ExecuteUpdate(s => s.SetProperty(
        p => p.Cost,
        p => p.Cost + amount));

        int[] productIds = products.Select(p => p.ProductId).ToArray();

        return (affected, productIds);
    }
}

Program.cs에서는 IncreaseProductPricesBetter method를 호출하는 문을 아래와 같이 추가합니다.

var resultUpdateBetter = IncreaseProductPricesBetter(productNameStartsWith: "Apple", amount: 20M);

if (resultUpdateBetter.affected > 0)
{
    Console.WriteLine("Increase product price successful.");
}

ListProducts(productIdsToHighlight: resultUpdateBetter.productIds);

다만 위 예제를 실행하기 전 Apple로 시작하는 product를 이전에 삭제하였으므로 위에서 구현했던 새로운 product를 추가하는 문을 먼저 실행하도록 해야 합니다.

예제를 실행하면 현재 'Apple'로 시작하는 product에 대해 다음과 같이 cost를 변경하였음을 확인할 수 있습니다.

다시 Modifications.cs로 돌아와 ExecuteDelete를 사용해 지정한 값으로 시작되는 모든 product를 삭제하는 method를 아래와 같이 추가합니다.

static int DeleteProductsBetter(string productNameStartsWith)
{
    using (Northwind db = new())
    {
        int affected = 0;
        IQueryable<Product>? products = db.Products?.Where(p => p.ProductName.StartsWith(productNameStartsWith));

        if ((products is null) || (!products.Any()))
        {
            Console.WriteLine("No products found to delete.");
            return 0;
        }
        else
        {
            affected = products.ExecuteDelete();
        }

        return affected;
    }
}

Program.cs에서 DeleteProductsBetter method를 호출하도록 하고 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

Console.WriteLine("About to delete all products whose name starts with Apple.");
Console.Write("Press Enter to continue or any other key to exit: ");

if (Console.ReadKey(intercept: true).Key == ConsoleKey.Enter)
{
    int deleted = DeleteProductsBetter(productNameStartsWith: "Apple");
    Console.WriteLine($"{deleted} product(s) were deleted.");
}
else
{
    Console.WriteLine("Delete was canceled.");
}

만약 기존 방식인 변경 추적과 ExecuteUpdate, ExecuteDelete method를 섞어서 사용하게 되는 경우라면 이들은 서로 동기화되지 않음에 주의해야 합니다. Change tracker는 이들 method를 통해 update 하고 delete 한 사항을 알지 못합니다.

(5) Database context pooling

DbContext class는 일회용이며 단일 작업 단위 원칙에 따라 설계되었습니다. 이전 예제에서는 DbContext에서 파생된 Northwind instance를 using안에서 생성했으므로 Dispose속성은 각 작업에서의 종료시점에 호출됩니다.

EF Core와 관련된 ASP.NET Core의 특징 중 하나는 website와 service를 구축할 때 database context를 pooling 함으로써 code를 더욱 효휼적으로 만든다는 것입니다. 이때 따라 가능한한 더 효휼적으로 원하는 만큼의 DbContext에서 파생된 다수의 개체를 생성하고 소멸할 수 있습니다.

7. Transaction

SaveChanges method를 호출할 때마다 암시적으로 transaction이 시작되므로 무엇인가 잘못된 상황이 발생하면 자동적으로 변경사항이 rollback 됩니다. Transaction이내에서 다수의 변경사항이 성공적으로 수행된다면 transaction은 모든 변경사항을 commit 합니다.

Transaction은 일련의 변경사항들을 처리하는 동안 해당 data에 대한 읽기/쓰기를 방지하지 위해 lock을 적용함으로써 database에 대한 무결성을 관리합니다.

Transaction은 아래 설명에 따른 약자로 ACID라고 말하기도 합니다.

A는 원자성(atomic)입니다. Transaction에 대한 모든 동작이 commit 되거나 commit 되지 않습니다.
C는 일관성(consistent)입니다. Transaction전후에 대한 database의 상태는 일관되며 이는 code의 logic에 의존합니다. 예를 들어 은행 계좌 간 돈이 송금될 때 하나의 계정에서 100만 원이 인출되면 다른 계정에서 100만원이 입금되어야 하는데 이를 보장하는 것은 business loginc에 달려있습니다.
I는 격리성(isolated)입니다. Transaction동안 변경사항은 다른 process로부터는 감춰지는데 여기에 선태가능한 여러 격리 수준이 존재합니다(아래 표 참고). 수준이 높을수록 data의 원자성은 더 나아지지만 더 많은 lock이 적용되고 이는 다른 process에 부정적인 영향을 줄 수 있습니다. Snapshot은 lock을 회피하기 위해 row의 여러 복사본을 생성하므로 좀 더 특별한 경우라고 할 수 있지만 transaction이 발생하는 동안 database의 크기를 증가시킬 수 있습니다.
D는 지속성(durable)입니다. Transaction이 실패하면 원상태로 복구될 수 있습니다. 이는 대게 2단계 commit과 transaction log로 구현됩니다. 일단 transaction이 commit 되면 후속 오류가 발생하더라도 data의 보존을 보증합니다. 지속성의 반대는 휘발성(volatile)입니다.

(1) 격리 수준을 통한 transaction 제어

Transaction은 격리 수준을 설정함으로써 아래 표의 설명과 같이 제어할 수 있습니다.

격리 수준	잠금	허용되는 무결성 문제
ReadUncommitted	해당없음	Dirty read, non-repeatable read와 phantom data
ReadCommitted	data변경시 data에 접근하는 다른 사용자를 transaction이 종료될때까지 차단하기 위해 읽기 잠금을 적용합니다.	Non-repeatable read와 phantom data
RepeatableRead	data를 읽을때 data에 접근하는 다른 사용자를 transaction이 종료될때까지 차단하기 위해 변경 잠금을 적용합니다.	Phantom data
Serializable	Insert나 delete를 포함해 결과에 영향을 줄 수 있는 모든 동작을 차단하기 위해 key-range잠금을 적용합니다.	해당없음
Snapshot	해당없음	해당없음

(2) 명시적인 transaction 정의

Database context에는 Database 속성이 있으며 이를 통해 transaction을 명시적으로 실행시킬 수 있습니다.

Modifications.cs에서 아래와 같이 namespace를 import 합니다. 이는 IDbContextTransaction interface를 사용하기 위한 EF Core storage namespace입니다.

using Microsoft.EntityFrameworkCore.Storage;

그리고 DeleteProducts method에서 db 변수의 instance를 생성한 직후 transaction을 명시적으로 시작하고 격리 수준을 출력하는 문을 추가합니다. Method의 끝에서는 transaction을 commit 하도록 합니다.

static int DeleteProducts(string productNameStartsWith)
{
    using (Northwind db = new())
    {
        using (IDbContextTransaction t = db.Database.BeginTransaction())
        {
            Console.WriteLine("Transaction isolation level: {0}", arg0: t.GetDbTransaction().IsolationLevel);

            IQueryable<Product>? products = db.Products?.Where(p => p.ProductName.StartsWith(productNameStartsWith));

            if ((products is null) || (!products.Any()))
            {
                Console.WriteLine("No products found to delete.");

                return 0;
            }
            else
            {
                if (db.Products is null) return 0;
                db.Products.RemoveRange(products);
            }

            int affected = db.SaveChanges();

            t.Commit();

            return affected;
        }
    }
}

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

[C# 12와 .NET 8] 9. File, Streams, Serialization

클리엘 — Wed, 28 Feb 2024 15:23:06 +0900

Data에 대한 입출력의 대상은 file이나 stream이 될 수 있으며 때로는 text를 encoding 하거나 직렬화할 수 있습니다.

1. File System 관리

Application에서는 종종 다른 환경에서 file이나 directory등으로 입출력 동작을 수행해야 할 경우가 있으며 System 및 System.IO namespace에서는 이러한 목적의 class들을 포함하고 있습니다.

(1) cross-platform 환경및 filesystem

우선 cross-platform환경을 처리하는 방법과 Windows와 Linux 또는 macOS사이의 차이점에 대해 알아보고자 합니다. Windows와 macOS 그리고 Linux에서 경로는 다르게 취급되고 있으므로 .NET이 이를 어떻게 처리하는지를 알아둘 필요가 있습니다.

csStudy08 Solution에서 WorkingWithFileSystems이름의 Console App project를 생성합니다. 그리고 project에 Helpers.cs 이름의 class file을 추가한뒤 아래와 같이 SectionTitle method를 가진 partial Program class를 정의합니다.

static void SectionTitle(string title)
{
	ConsoleColor previousColor = System.Console.ForegroundColor;
	System.Console.ForegroundColor = ConsoleColor.Yellow;
	Console.WriteLine("*");
	Console.WriteLine($"* {title}");
	Console.WriteLine("*");
	System.Console.ForegroundColor = previousColor;
}

Program.cs에서는 기존의 문을 모두 삭제하고 System.IO.Directory, System.Environment, System.IO.Path namespace를 정적 import한뒤

using static System.IO.Directory; 
using static System.IO.Path; 
using static System.Environment;

여기에 경로 및 directory분리문자를 출력하고, 현재 directory에 대한 경로와 system file, 임시 file, document 등 일부 특별한 용도의 directory에 대한 경로를 출력하는 문을 아래와 같이 작성합니다.

Console.WriteLine("{0,-33} {1}", arg0: "Path.PathSeparator", arg1: PathSeparator);
Console.WriteLine("{0,-33} {1}", arg0: "Path.DirectorySeparatorChar", arg1: DirectorySeparatorChar);
Console.WriteLine("{0,-33} {1}", arg0: "Directory.GetCurrentDirectory()", arg1: GetCurrentDirectory());
Console.WriteLine("{0,-33} {1}", arg0: "Environment.CurrentDirectory", arg1: CurrentDirectory);
Console.WriteLine("{0,-33} {1}", arg0: "Environment.SystemDirectory", arg1: SystemDirectory);
Console.WriteLine("{0,-33} {1}", arg0: "Path.GetTempPath()", arg1: GetTempPath());

Console.WriteLine("GetFolderPath(SpecialFolder)");
Console.WriteLine("{0,-33} {1}", arg0: " .System)", arg1: GetFolderPath(SpecialFolder.System));
Console.WriteLine("{0,-33} {1}", arg0: " .ApplicationData)", arg1: GetFolderPath(SpecialFolder.ApplicationData));
Console.WriteLine("{0,-33} {1}", arg0: " .MyDocuments)", arg1: GetFolderPath(SpecialFolder.MyDocuments));
Console.WriteLine("{0,-33} {1}", arg0: " .Personal)", arg1: GetFolderPath(SpecialFolder.Personal));

Environment type에서는 위의 예제에서 사용된 것 이외 GetEnvironmentVariables method와 OSVersion, ProcessorCount속성등 여러 가지 유용한 member들을 가지고 있습니다.

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

Visual Studio Code에서 dotnet run을 사용해 console app을 실행하는 경우 CurrentDirectory는 bin folder 내부가 아닌 project folder가 될 것입니다.

Windows에서는 directory에 대한 구분문자로 backslash(\)문자를 사용하지만 macOS와 Linux는 slash문자를 사용합니다. 경로를 결합할 때 code에서 어떤 문자가 사용되는지를 미리 가정하지 말고 Path.DirectorySeparatorChar를 사용하는 것이 좋습니다.

(2) Drive

Drive에 관한 것으로는 computer에 연결된 모든 drive에 관한 정보를 반환하는 정적 method를 가진 DriveInfo type을 사용합니다. 이때 각각의 drive는 drive type을 가집니다.

Program.cs에서 모든 drive를 가져와 사용가능한 것들에 대해서만 drive의 이름, type, size, 사용 가능한 용량 그리고 format을 출력하는 문을 작성합니다.

SectionTitle("My drives");
Console.WriteLine("{0,-30} | {1,-10} | {2,-7} | {3,18} | {4,18}", "NAME", "TYPE", "FORMAT", "SIZE (BYTES)", "FREE SPACE");
foreach (DriveInfo drive in DriveInfo.GetDrives())
{
	if (drive.IsReady)
	{
		Console.WriteLine("{0,-30} | {1,-10} | {2,-7} | {3,18:N0} | {4,18:N0}", drive.Name, drive.DriveType, drive.DriveFormat, drive.TotalSize, drive.AvailableFreeSpace);
	}
	else
	{
		Console.WriteLine("{0,-30} | {1,-10}", drive.Name, drive.DriveType);
	}
}

TotalSize와 같은 속성을 읽기 전에 drive가 준비상태인지를 확인해야 합니다. 그렇지 않으면 이동식 drive에 관한 예외를 보게 될 것입니다.

예제를 실행하면 다음과 같은 결과를 확인할 수 있습니다.

Linux에서 일반 사용자 권한으로 예제를 실행하는 경우 Name과 DriveType만 접근이 가능하고 DriveFormat과 TotalSize에서는 UnauthorizedAccessException예외를 일으킬 수 있습니다.이 문제를 해결하기 위해서는 ' sudo dotnet run.'명령을 통해서 관리자 권한으로 예제를 실행해야 합니다.

(3) Directory

Directory와 관련해서는 Directory, Path 그리고 Environment 적정 class를 사용합니다. 이들 type에는 filesystem에 관한 다수의 member들을 가지고 있습니다.

사용자지정 경로를 구성할 때는 예를 들어 directory분리문자를 사용할 때 platform에 대한 가정을 하지 않도록 code작성에 주의해야 합니다.

Program.cs에서 directory 이름에 대한 문자열을 생성하고 Path type의 Combine method를 통해 적절히 이들을 결합하여 사용자의 home directory 아래에 사용자지정 경로를 정의하도록 하는 문을 아래와 같이 작성합니다. 이때 사용자지정 directory에 대한 경로는 Directory class의 Exists method를 통해 존재여부를 확인하고 directory를 생성한 뒤 Directory class의 CreateDirectory method와 Delete method를 사용해 이곳에 포함된 모든 file과 하위 directory를 포함해 삭제하도록 합니다.

SectionTitle("Custom Directory");
			
string newFolder = Combine(GetFolderPath(SpecialFolder.Personal), "NewFolder");

Console.WriteLine($"Working with: {newFolder}");
Console.WriteLine($"Does it exist? {Path.Exists(newFolder)}");
Console.WriteLine("Creating it...");
			
CreateDirectory(newFolder);

Console.WriteLine($"Does it exist? {Path.Exists(newFolder)}");
Console.Write("Confirm the directory exists, and then press ENTER: "); Console.ReadLine();
Console.WriteLine("Deleting it...");
			
Delete(newFolder, recursive: true);

Console.WriteLine($"Does it exist? {Path.Exists(newFolder)}");

예제를 실행한 뒤 결과를 확인합니다. directory를 삭제하기 위해 Enter key를 누르기 전 해당 directory가 정상적으로 만들어졌는지 확인합니다.

.NET 6 이전까지는 Directory class에서만 Exists method가 있었으나 .NET 7 이후부터는 Path에도 Exists method가 존재하며 둘의 역활은 동일합니다.

(4) File

File과 관련해서는 Directory에서 했던 것처럼 file type을 정적으로 가져올 수 있습니다. 다만 아래 예제에서는 directory type에서와 이름이 같은 method를 일부 가지고 있으며 따라서 서로 충돌할 수 있기 때문에 그런 방식을 사용하지 않았습니다. 또한 이 경우 큰 문제가 되지 않을 만큼 짧은 이름을 사용할 수 있습니다.

Program.cs에서 파일존재를 확인한 뒤 text file을 생성하고 해당 file에 text를 기록하는 문을 작성합니다.

SectionTitle("files");

string dir = Combine(GetFolderPath(SpecialFolder.Personal), "OutputFiles");
CreateDirectory(dir);

string textFile = Combine(dir, "Dummy.txt");
string backupFile = Combine(dir, "Dummy.bak");

Console.WriteLine($"Working with: {textFile}");
Console.WriteLine($"Does it exist? {File.Exists(textFile)}");

StreamWriter textWriter = File.CreateText(textFile);
textWriter.WriteLine("Hello, C#!");
textWriter.Close();

Console.WriteLine($"Does it exist? {File.Exists(textFile)}");

File.Copy(sourceFileName: textFile, destFileName: backupFile, overwrite: true);
Console.WriteLine($"Does {backupFile} exist? {File.Exists(backupFile)}");

Console.Write("Confirm the files exist, and then press ENTER: ");
Console.ReadLine();
			
File.Delete(textFile);
Console.WriteLine($"Does it exist? {File.Exists(textFile)}");
			
Console.WriteLine($"Reading contents of {backupFile}:");
StreamReader textReader = File.OpenText(backupFile);
Console.WriteLine(textReader.ReadToEnd());
textReader.Close();

예제에서는 file을 기록하고 나면 system resource와 잠금을 해제하기 위해 file을 닫아줍니다.(이것은 일반적으로 file작성 시 예외가 발생하더라도 file이 닫히는 경우를 확실히 하기 위해 try-finally문에서 이루어집니다.) 그리고 backup을 위해 file을 복사한 뒤 기존의 file은 삭제하고 backup file로부터 내용을 읽어 표시합니다.

예제를 실행하면 다음과 같은 결과를 확인할 수 있습니다.

(5) Path

때로는 경로의 일부만을 확인해야 하는 경우도 있을 것입니다. 예를 들어 경로에서 folder이름이나 file이름, 혹은 확장자와 같은 것만을 추출해야 하는 경우입니다. 또는 임시 folder나 file이름을 생성해야 하는 경우도 있습니다. 이와 같은 작업은 Path class의 정적 method를 사용하면 가능합니다.

Program.cs에서 아래와 같은 구문을 추가합니다.

SectionTitle("Paths");
string dir = Combine(GetFolderPath(SpecialFolder.Personal), "OutputFiles");
string textFile = Combine(dir, "Dummy.txt");

Console.WriteLine($"Folder Name: {GetDirectoryName(textFile)}");
Console.WriteLine($"File Name: {GetFileName(textFile)}");
Console.WriteLine("File Name without Extension: {0}",

GetFileNameWithoutExtension(textFile));

Console.WriteLine($"File Extension: {GetExtension(textFile)}");
Console.WriteLine($"Random File Name: {GetRandomFileName()}");
Console.WriteLine($"Temporary File Name: {GetTempFileName()}");

예제를 실행하면 다음과 같은 결과를 확인할 수 있습니다.

GetTempFileName은 zero-byte file을 생성하여 사용할 수 있도록 준비한 뒤 해당 file의 이름을 반환합니다. 하지만 GetRandomFileName은 file의 이름만 반환할 뿐 실제 생성하지는 않습니다.

(6) File 정보 확인

File이나 directory에 관한 정보, 예를 들어 size나 마지막 접근일자와 같은 정보를 를 확인하려면 FileInfo 혹은 DirectoryInfo class의 instance를 생성해 사용할 수 있습니다.

FileInfo와 DirectoryInfo는 모두 FileSystemInfo class로부터 상속받은 것으로 따라서 둘 다 자신만의 속성과 더불어 LastAccessTime나 Delete와 같은 공통된 member를 가지고 있습니다.

Class	Members
FileSystemInfo	Field : FullPath, OriginalPath Property : Attributes, CreationTime, CreationTimeUtc, Exists, Extension, FullName, LastAccessTime, LastAccessTimeUtc, LastWriteTime, LastWriteTimeUtc, Name Methods: Delete, GetObjectData, Refresh
DirectoryInfo	Property : Parent, Root Method : Create, CreateSubdirectory, EnumerateDirectories, EnumerateFiles, EnumerateFileSystemInfos, GetAccessControl, GetDirectories, GetFiles, GetFileSystemInfos, MoveTo, SetAccessControl
FileInfo	Property : Directory, DirectoryName, IsReadOnly, Length Methods: AppendText, CopyTo, Create, CreateText, Decrypt, Encrypt, GetAccessControl, MoveTo, Open, OpenRead, OpenText, OpenWrite, Replace, SetAccessControl

아래 예제는 하나의 File에 대해 FileInfo instance를 통해 여러 동작을 어떻게 효휼적으로 수행할 수 있는지를 알려주기 위한 것으로 Program.cs에서 backup file에 대한 FileInfo instance를 생성하고 console에 이에 대한 정보를 출력하도록 합니다.

SectionTitle("File information");

string dir = Combine(GetFolderPath(SpecialFolder.Personal), "OutputFiles");
string backupFile = Combine(dir, "Dummy.bak");

FileInfo info = new(backupFile);
Console.WriteLine($"{backupFile}:");
Console.WriteLine($"Contains {info.Length} bytes");
Console.WriteLine($"Last accessed {info.LastAccessTime}");
Console.WriteLine($"Has readonly set to {info.IsReadOnly}");

예제를 실행하면 다음과 같은 결과를 표시하게 됩니다.

byte에 대한 숫자는 OS마다 다른 line ending을 사용할 수 있으므로 다르게 표시될 수 있습니다.

(7) File에 대한 처리방식 제어

File에 대한 어떤 처리를 진행하고자 할 때 경우에 따라 어떤 형태로 file을 open 해야 할지 지정하는 경우가 있으며 이런 경우 File.Open method를 사용할 수 있습니다. Open method는 enum값을 통해 추가적인 option을 지정할 수 있는 overload를 가지고 있습니다.

사용가능한 enum값으로는 다음과 같은 것이 있습니다.

FileMode : CreateNew, OpenOrCreate, Truncate 등 해당 file에 무엇을 할지 지정합니다.
FileAccess : ReadWrite와 같이 필요한 접근 수준을 지정합니다.
FileShare : 다른 process에서 Read와 같이 접근가능한 수준을 지정함으로써 file에 대한 잠금을 조정합니다.

따라서 만약 file을 열고 해당 file로부터 읽기를 수행하면서 다른 process에서도 역시 읽기를 허용하려면 다음과 같이 지정합니다.

FileStream file = File.Open(textFile, FileMode.Open, FileAccess.Read, FileShare.Read);

또한 file에 대한 속성을 위해 사용가능한 아래와 enum값도 존재합니다.

FileAttributes : FileSystemInfo에서 파생된 type의 attrubute 속성에서 Archive와 Encrypted와 같은 값을 확인합니다.

이를 통해 file이나 directory의 속성은 아래와 같이 확인할 수 있습니다.

FileInfo info = new(backupFile);
WriteLine("Is the backup file compressed? {0}", info.Attributes.HasFlag(FileAttributes.Compressed));

2. Stream 읽기/쓰기

Stream은 읽고 쓸 수 있는 일련의 byte입니다. File을 array처럼 처리할 수 있지만 file내 byte의 위치를 알면 random access가 제공되므로 순차적으로 접근할 수 있는 stream으로서 file을 처리하는 것이 유용할 수 있습니다.

Stream은 또한 terminal 입출력 및 random access를 제공하지 않으며 위치를 탐색(즉, 이동)할 수 없는 socket과 port 같은 networking resource를 처리하는 데에도 사용할 수 있습니다. 이에 따라 data stream이 어디서 온 것인지 신경 쓸 필요 없이 임의의 byte를 처리할 수 있는 code를 작성할 수 있으며 이때 code는 단순히 stream을 읽고 쓰기만 하면 다른 한편에서는 실제 byte가 저장된 곳을 처리할 수 있게 됩니다.

(1) Stream의 추상화 및 구체화

Stream이라는 추상화 class는 stream에 대한 모든 type을 표현합니다. 추상화 class자체는 new를 사용해 instance를 생성할 수 없으며 상속만이 가능합니다.

때문에 해당 기반 class로부터 상속된 다수의 구체화 class가 존재하는데 여기에는 FileStream, MemoryStream, BufferedStream, GZipStream 그리고 SslStream과 같은 것이 존재하며 이들은 모두 같은 방식으로 작동합니다. 모든 stream은 IDisposable interface를 구현하고 있으므로 비관리 resource를 해제하기 위한 Dispose method를 가집니다.

Stream class에서 가지고 있는 일부 공통 member에 관해서는 아래 표에서 확인할 수 있습니다.

Member	Description
CanRead, CanWrite	해당 속성은 stream을 읽거나 쓸수 있는지의 여부를 나타냅니다.
Length, Position	해당 속성은 총 byte길이와 stream에서의 현재 위치를 나타냅니다.
Dispose	해당 method는 stream을 닫고 resource를 해제합니다.
Flush	Stream이 bufer를 가지고 있다면 해당 method는 buffer의 byte를 stream에 기록하고 buffer를 비웁니다.
CanSeek	해당 속성은 Seek method가 사용가능한지를 나타냅니다.
Seek	해당 method는 현재 위치를 매개변수로 지정된 곳으로 이동합니다.
Read, ReadAsync	해당 method는 stream으로 부터 지정한 수의 byte를 byte배열로 읽고 위치를 앞당깁니다.
ReadByte	해당 method는 stream으로 부터 다음 byte를 읽고 위치를 앞당깁니다.
Write, WriteAsync	해당 method는 byte array의 내용을 stream으로 작성합니다.
WriteByte	해당 method는 byte를 stream으로 작성합니다.

● Storage stream

아래 표에서는 byte가 저장될 위치를 나타내는 일부 storage stream을 설명하고 있습니다.

Namespace	Class	Description
System.IO	FileStream	filesystem에 저장된 byte
System.IO	MemoryStream	현재 process의 memory에 저장된 byte
System.Net.Sockets	NetworkStream	network 위치에 저장된 byte

File Stream은 Windows상에서 성능과 안정성이 더육 향상되도록 .NET 6에서 재작성되었습니다.

File IO improvements in .NET 6 - .NET Blog (microsoft.com)

● Function stream

아래 표는 자체적으로는 존재하지 않지만 다른 stream에 연결되어 기능을 추가시키는 function stream을 설명하고 있습니다.

Namespace	Class	Description
System.Security.Cryptography	CryptoStream	Stream을 암호화/복호화 합니다.
System.IO.Compression	GZipStream, DeflateStream	Stream을 압축하고 해제합니다.
System.Net.Security	AuthenticatedStream	Stream전역에 자격증명을 보냅니다.

● Stream helper

비록 저수준에서 stream을 사용해야 하는 경우가 있겠지만 대부분은 helper class를 사용하는 것만으로 손쉽게 구현할 수 있습니다. Stream에 대한 모든 helper type은 IDisposable을 구현하고 있으므로 비관리 resource를 해제하기 위한 Dispose method를 가집니다.

일반적인 상황에서 사용가능한 몇몇 helper class는 아래 표에 안내되어 있습니다.

Namespace	Class	Description
System.IO	StreamReader	기본 stream으로 부터 일반 text를 읽습니다.
System.IO	StreamWriter	기본 stream으로 일반 text를 작성합니다.
System.IO	BinaryReader	Stream으로 부터 .NET type을 읽습니다. 예를 들어 ReadDecimal method는 기본 stream에서 decimal 값을 다음 16 byte를 읽고 ReadInt32 method는 int값으로 다음 4 byte를 읽습니다.
System.IO	BinaryWriter	Stream으로 .NET type을 작성합니다. 예를 들어 decimal 매개변수를 가진 Write method는 기본 stream으로 16byte를 작성하며 int 매개변수를 가진 Write method는 4 byte를 작성합니다.
System.Xml	XmlReader	기본 stream으로 부터 XML format을 사용해 읽습니다.
System.Xml	XmlWrite	기본 stream으로 XML format을 사용해 작성합니다.

(2) Stream pipeline 구축

StreamWriter와 같은 helpler와 CryptoStream이나 GZipStream과 같은 여러 기능 Stream을 stream을 저장하는 FileStream과 pipeline으로 결합하는 것은 흔한 경우입니다.

WriteLine method를 통해 hello라는 문자열을 pipeline을 통해서 보내면 이것은 암호화와 압축 stream을 거쳐게 되고 최종목적지에 도달하게 되면 'G7x'라고 쓰여진 file의 결과물을 얻게 됩니다.

(3) Text stream

Stream으로 text를 작성하는 예제를 만들기 위해 csStudy09 solution을 생성하고 이어서 WorkingWithStreams이름의 Console app project를 추가합니다.

Project가 생성되면 Viper.cs라는 이름의 class file을 추가하고 Callsigns이름의 문자열배열값을 가진 Viper이름의 정적 class를 아래와 같이 작성합니다.

Program.cs에서는 기존의 문을 모두 삭제하고 System.Xml namespace와 System.Environment, System.IO.path namespace를 정적 import 합니다. 그리고 Viper call signs를 열거하면서 각각 한 줄씩 text file에 기록하도록 하는 문을 아래와 같이 작성합니다.

string textFile = Combine(CurrentDirectory, "streams.txt");
            
// text file을 생성한 뒤 helper writer를 반환
StreamWriter text = File.CreateText(textFile);
            

foreach (string item in Viper.Callsigns)
{
    text.WriteLine(item);
}

text.Close(); // release resources

// file의 크기와 내용 출력
Console.WriteLine("{0} contains {1:N0} bytes.", arg0: GetFileName(textFile), arg1: new FileInfo(textFile).Length);
Console.WriteLine(File.ReadAllText(textFile));

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

(4) XML stream

XML 요소를 작성하는 데는 2가지 방식이 존재합니다.

WriteStartElement와 WriteEndElement : 요소가 자식요소를 가지는 경우 같이 사용합니다.
WriteElementString : 요소가 자식요소를 가지지 않는 경우 사용합니다.

읽거나 쓰기 위해 file을 열면 .NET의 외부 resource를 사용하는 것으로 이를 비관리 resouce라고 하며 대상 file에 대한 작업이 종료되면 instance는 반드시 소멸되어야 하며 대게는 resource를 소멸할 때 try ~ finally block안에서 Dispose method를 호출합니다.

아래 예제는 Viper pilot 호출 sign에 대한 문자열 배열값을 XML file로 저장하도록 하는 것으로 Program.cs에서 호출 sign을 열거하고 각각을 단일 XML file의 요소로 작성하도록 합니다.

//작성을 위한 file경로 정의
string xmlFile = Combine(CurrentDirectory, "streams.xml");

// filestream과 XML writer에 대한 변수 선언
FileStream? xmlFileStream = null;
XmlWriter? xml = null;

try
{
    // file stream 생성
    xmlFileStream = File.Create(xmlFile);
    // file stream을 XML writer helper로 wrapping하고 자동적으로 중첩된 요소간 들여쓰기를 적용합니다.
    xml = XmlWriter.Create(xmlFileStream, new XmlWriterSettings { Indent = true });

    xml.WriteStartDocument();
    // root 요소 작성
    xml.WriteStartElement("callsigns");

    //string을 열거하고 각각을 stream에 작성합니다.
    foreach (string item in Viper.Callsigns)
    {
        xml.WriteElementString("callsign", item);
    }

    // 종료 root 요소 작성
    xml.WriteEndElement();
    // helper와 stream닫기
    xml.Close();
    xmlFileStream.Close();
}
catch (Exception ex) {
    //해당 경로가 존재하지 않으면 예외발생
    Console.WriteLine($"{ex.GetType()} says {ex.Message}");
}
finally {
    if (xml != null)
    {
        xml.Dispose();
        Console.WriteLine("비관리 resource 해제");
    }

    if (xmlFileStream != null)
    {
        xmlFileStream.Dispose();
        Console.WriteLine("File stream의 비관리 resource 해제");
    }
}

//File 내용 출력
Console.WriteLine("{0} contains {1:N0} bytes.", arg0: Path.GetFileName(xmlFile), arg1: new FileInfo(xmlFile).Length);
Console.WriteLine(File.ReadAllText(xmlFile));

예제를 실행하면 아래와 같은 결과를 표시합니다.

Dispose method를 호출하기 전 개체가 null인지를 확인해야 합니다.

(5) using문을 사용해 소멸을 단순화하기

위 예제에서는 null 개체에 대한 확인 code를 좀 더 단순화한 다음 using 문을 통해 Dispose method를 호출하도록 바꿀 수 있습니다. 일반적으로는 더 높은 수준에서의 제어가 필요하지 않은 이상에는 수동적으로 Dispose method를 호출하기보다는 using문의 사용을 권장합니다.

using keyword자체가 namespace를 import 하고 IDisposable를 구현하는 개체에 Dispose를 호출할 finally문을 생성하는 2가지로 사용된다는 측면에서 약간 혼란스러울 수 있지만 실제 사용해 보면 이 둘은 아주 명확히 구분된다는 것을 알 수 있을 것입니다.

아래 예제에서 compiler는 using 문 block을 catch문이 없는 try-finally문으로 변경합니다. 물론 여기에서도 try문을 충첩적으로 사용할 수 있으므로 어떤 예외사항을 잡아내야 한다면 아래와 같이 구현할 수 있습니다.

using (FileStream file = File.OpenWrite(Path.Combine(CurrentDirectory, "test.txt")))
{
    using (StreamWriter writer = new StreamWriter(file))
    {
        try
        {
            writer.WriteLine(".NET!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{ex.GetType()} says {ex.Message}");
        }
    } // 개체가 null이 아니면 자동적으로 Dispose를 호출
} // 개체가 null이 아니면 자동적으로 Dispose를 호출

게다가 위 예제는 using문을 위한 괄호와 들여 쓰기를 명시하지 않음으로써 아래와 같이 더욱 간소화할 수 있습니다.

using FileStream file = File.OpenWrite(Path.Combine(CurrentDirectory, "test.txt"));
using StreamWriter writer = new(file);

try
{
    writer.WriteLine(".NET!");
}
catch (Exception ex)
{
    Console.WriteLine($"{ex.GetType()} says {ex.Message}");
}

(6) Stream 압축

XML은 상대적으로 장황한 편이라 일반적인 text보다 더 많은 byte공간을 차지하게 됩니다. 이제 GZIP이라는 일반적인 압축 algorithm을 사용하여 XML을 얼마나 압축할 수 있는지를 확인해 볼 것입니다.

.NET Core 2.1에서 Microsoft는 Brotli이라는 압축 algorithm의 구현을 도입하였습니다. 성능면에서 Brotli는 DEFLATE와 GZIP에서 사용된 algorithm과 비슷하지만 20% 정도 더 압축력이 높다고 평가되고 있습니다.

예제를 통해 GZIP과 Brotli 2개의 압축 algorithm을 비교해 보고자 Project에 Compress.cs라는 class file을 추가합니다. Compress.cs에서는 GZipStream과 BrotliStream에 대한 instance를 사용하여 위와 동일한 XML 요소를 포함하는 압축 file을 생성한 다음 읽는 동안 압축을 풀고 console에 해당 내용을 출력하는 문을 아래와 같이 작성합니다.

using System.IO.Compression; // BrotliStream, GZipStream, CompressionMode
using System.Xml; // XmlWriter, XmlReader
using static System.Environment; // CurrentDirectory
using static System.IO.Path; // Combine

namespace WorkingWithStreams
{
    partial class Program
    {
        static void Compress(string algorithm = "gzip")
        {
            //file의 확장자를 통해 algorithm을 사용하는 file 경로 정의
            string filePath = Combine(CurrentDirectory, $"streams.{algorithm}");

            FileStream file = File.Create(filePath);
            Stream compressor;

            if (algorithm == "gzip")
            {
                compressor = new GZipStream(file, CompressionMode.Compress);
            }
            else
            {
                compressor = new BrotliStream(file, CompressionMode.Compress);
            }

            using (compressor)
            {
                using (XmlWriter xml = XmlWriter.Create(compressor))
                {
                    xml.WriteStartDocument();
                    xml.WriteStartElement("callsigns");
                    foreach (string item in Viper.Callsigns)
                    {
                        xml.WriteElementString("callsign", item);
                    }
                }
            }

            Console.WriteLine("{0} contains {1:N0} bytes.", Path.GetFileName(filePath), new FileInfo(filePath).Length);
            Console.WriteLine($"The compressed contents:");
            Console.WriteLine(File.ReadAllText(filePath));
            
            Console.WriteLine("Reading the compressed XML file:");
            file = File.Open(filePath, FileMode.Open);
            Stream decompressor;

            if (algorithm == "gzip")
            {
                decompressor = new GZipStream(file, CompressionMode.Decompress);
            }
            else
            {
                decompressor = new BrotliStream(file, CompressionMode.Decompress);
            }

            using (decompressor)
            {

                using (XmlReader reader = XmlReader.Create(decompressor))
                {

                    while (reader.Read())
                    {
                        //callsign 요소가 있는지 확인
                        if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "callsign"))
                        {
                            reader.Read(); //요소 내부 text로 이동
                            Console.WriteLine($"{reader.Value}"); //해당 값 읽기
                        }
                    }
                }
            }
        }
    }
}

Program.cs에서는 gzip과 brotli algorithm을 사용하기 위한 매개변수와 함께 Compress method를 호출하는 문을 아래와 같이 작성합니다.

Compress(algorithm: "gzip");
Compress(algorithm: "brotli");

예제를 실행하면 다음과 같이 XML file과 gzip 및 brotli algorithm을 통해 압축된 XML file의 size를 비교하는 결과를 표시하게 됩니다.

당연한 이야기지만 압축된 file은 압축되지 않은 동일한 file size의 size보다 훨씬 적음을 알 수 있습니다.

압축 mode와 더불어 압축 level역시 선택할 수 있습니다. 자세한 사항은 아래 link를 참고해 주시기 바랍니다.

CompressionLevel Enum (System.IO.Compression) | Microsoft Learn

CompressionLevel Enum (System.IO.Compression)

Specifies values that indicate whether a compression operation emphasizes speed or compression size.

learn.microsoft.com

(7) tar 압축

확장자가 .tar인 file은 Unix기반의 압축 application인 tar에 의해 생성된 것입니다. 확장자가 .tag.gz인 file도 존재하는데 이는 tar로 file이 만들어지고 GZIP 압축 algorithm을 사용해 압축되어 생성된 것임을 의미합니다.

.NET 7에서는 System.Formats.Tar assembly를 통해 tar 압축 file을 읽고, 생성하며 압축하거나 풀 수 있습니다.

이와 관련해 TarFile class에서는 아래 표에서의 static public member를 사용할 수 있습니다.

Member	Description
CreateFromDirectory CreateFromDirectoryAsync	지정된 directory로 부터 지정된 모든 filesystem 항목을 포함하는 stream을 생성합니다.
ExtractToDirectory ExtractToDirectoryAsync	지정한 directory에서 tar 압축을 나타내는 stream의 content를 추출합니다.
DefaultCapacity	Windows의 MAX_PATH (260)이 임의 기본 용량으로 사용됩니다.

관련한 예제 작성을 위해 csStudy09 solution에서 WorkingWithTarArchives이름의 Console app project를 생성합니다. 그리고 Helpers.cs라는 class file을 추가하여 error, 경고, 정보 message를 console에 적절한 색상으로 출력하는 3개의 method를 가진 partial Program class를 아래와 같이 작성합니다.

using static System.Console;

namespace WorkingWithTarArchives
{
    partial class Program
    {
        static void WriteError(string message)
        {
            ConsoleColor previousColor = ForegroundColor;
            ForegroundColor = ConsoleColor.Red;
            WriteLine($"FAIL: {message}");
            ForegroundColor = previousColor;
        }

        static void WriteWarning(string message)
        {
            ConsoleColor previousColor = ForegroundColor;
            ForegroundColor = ConsoleColor.DarkYellow;
            WriteLine($"WARN: {message}");
            ForegroundColor = previousColor;
        }
        static void WriteInformation(string message)
        {
            ConsoleColor previousColor = ForegroundColor;
            ForegroundColor = ConsoleColor.Blue;
            WriteLine($"INFO: {message}");
            ForegroundColor = previousColor;
        }
    }
}

이어서 project의 실행 file이 동작하는 bin folder에 images라는 folder를 생성하고 아래 image들을 내려받은 뒤 해당 folder로 복사해 놓습니다.

images.zip

2.48MB

Program.cs에서는 기존의 문을 모두 삭제하고 지정한 folder의 content를 tar로 압축한 다음 이것을 다시 새로운 folder로 추출하는 구문을 아래와 같이 작성합니다.

try
{
    string current = Environment.CurrentDirectory;
    WriteInformation($"Current directory: {current.Split(Path.DirectorySeparatorChar).Last()}");

    string sourceDirectory = Path.Combine(current, "images");
    string destinationDirectory = Path.Combine(current, "extracted");
    string tarFile = Path.Combine(current, "images-archive.tar");

    if (!Directory.Exists(sourceDirectory))
    {
        WriteError($"The {sourceDirectory.Split(Path.DirectorySeparatorChar).Last()} directory must exist. Please create it and add some files to it.");
        return;
    }

    //tar file이 존재한다면 삭제
    if (File.Exists(tarFile))
    {
        File.Delete(tarFile);
        WriteWarning($"{Path.GetFileName(tarFile)} already existed so it was deleted.");
    }

    WriteInformation($"Archiving directory: {sourceDirectory.Split(Path.DirectorySeparatorChar).Last()}\n To .tar file: {Path.GetFileName(tarFile)}");

    TarFile.CreateFromDirectory(sourceDirectoryName: sourceDirectory, destinationFileName: tarFile, includeBaseDirectory: true);

    WriteInformation($"Does {Path.GetFileName(tarFile)} exist? {File.Exists(tarFile)}.");

    //destinationDirectory folder가 존재하지 않으면 새로 생성
    if (!Directory.Exists(destinationDirectory))
    {
        Directory.CreateDirectory(destinationDirectory);
        WriteWarning($"{destinationDirectory.Split(Path.DirectorySeparatorChar).Last()} did not exist so it was created.");
    }

    WriteInformation($"Extracting archive: {Path.GetFileName(tarFile)}\n To directory: {destinationDirectory.Split(Path.DirectorySeparatorChar).Last()}");

    TarFile.ExtractToDirectory(sourceFileName: tarFile, destinationDirectoryName: destinationDirectory, overwriteFiles: true);

    if (Directory.Exists(destinationDirectory))
    {
        foreach (string dir in Directory.GetDirectories(destinationDirectory))
        {
            WriteInformation($"Extracted directory {dir.Split(Path.DirectorySeparatorChar).Last()} containing these files: " + string.Join(',', Directory.EnumerateFiles(dir).Select(file => Path.GetFileName(file))));
        }
    }
}
catch (Exception ex)
{
    WriteError(ex.Message);
}

예제를 실행하면 다음과 같은 결과를 확인할 수 있습니다

만약 반디집과 같이 tar archive의 content를 볼 수 있는 software가 있다면 이 것을 사용해 images-archive.tar file의 content를 다음과 같이 확인합니다.

● tar 항목 읽기 및 쓰기

TarFile class 외에도 tar 압축 file에서 개별적인 항목을 읽고 쓰기 위한 TarEntry, TarEntryFormat, TarReader, TarWriter 등의 class가 존재합니다. 이들은 GzipStream과 결합하여 쓰거나 읽을 때 항목을 압축하거나 해제할 수 있습니다.

.NET에서 지원하는 tar에 관한 더 자세한 사항은 아래 link를 참고하시기 바랍니다.

System.Formats.Tar Namespace | Microsoft Learn

System.Formats.Tar Namespace

Contains types used in reading and writing data in the Tape Archive (TAR) file archiving format.

learn.microsoft.com

(8) Random access handle을 사용한 읽고 쓰기

.NET의 처음 20년 동안은 file을 직접적으로 처리하는 유일한 API는 stream class였습니다. 이들은 data를 순차적으로 처리해야 하는 자동화된 작업에 적합합니다. 하지만 사람이 data와 상호작용하는 경우 종종 같은 위치로 여러번 이동하고 되돌아 와야할 때가 있습니다. 이에 따라 .NET 6부터는 file stream이 필요없이 file에 대해 직접적으로 작동하면서 randome으로 접근할 수 있는 새로운 API를 도입하게 되었습니다.

해당 예제를 만들어 보기 위해 아래와 같이 code를 작성합니다. 이 예제는 myTxt.txt라는 file에 대한 handle을 가져오도록 합니다.

using Microsoft.Win32.SafeHandles;
using System.Text;

using SafeFileHandle handle = File.OpenHandle(path: "myTxt.txt", mode: FileMode.OpenOrCreate, access: FileAccess.ReadWrite);

그런다음 file에 저장할 내용을 아래와 같이 작성합니다. 이 예제는 abcdefg라는 문자열을 byte array로 encoding하여 읽기전용 memory buffer에 담은 다음 file로 저장하는 동작을 수행합니다.

ReadOnlyMemory<byte> buffer = new(Encoding.UTF8.GetBytes("abcdefg"));
await RandomAccess.WriteAsync(handle, buffer, fileOffset: 0);

file을 읽기위해서는 우선 file의 길이(length)값을 가져온 다음 그 값을 통해 읽은 content를 담아둘 memory buffer를 할당합니다.

long length = RandomAccess.GetLength(handle);
Memory<byte> contentBytes = new(new byte[length]);

await RandomAccess.ReadAsync(handle, contentBytes, fileOffset: 0);
string content = Encoding.UTF8.GetString(contentBytes.ToArray());
WriteLine($"파일내용: {content}");

3. Text의 encoding과 decoding

Text 문자는 다양한 방식으로 표현될 수 있습니다. 예를 들어 alphabet은 전신을 통해 전송할 수 있는 일련의 점과 선으로 구성되는 Morse 부호로 encode 될 수 있습니다.

비슷하게 computer에서의 text도 code의 공간 안에서 code point를 나타내는 bit(1과 0)로 저장됩니다. 대부분의 code point는 단일 문자로 표현되지만 형식지정과 같은 다른 의미를 가질 수도 있습니다.

예를 들어 ASCII는 128 code point를 가진 code공간을 가지고 있습니다. .NET은 Unicode라고 하는 표준을 통해 text를 내부적으로 endcode 합니다. Unicode는 백만 code point이상을 가지고 있습니다.

때로는 text를 Unicode를 사용하지 않거나 Unicode의 변형을 사용하는 system에서 사용하기 위해 .NET 외부로 보내야 하는 경우가 있는데 이 때문에 encoding사이에 변환방법을 아는 것은 중요합니다.

아래 표에서는 computer에서 일반적으로 사용되는 text ecoding을 나열하고 있습니다.

Encoding	Description
ASCII	byte중 하위 7bit만을 사용함으로서 문자의 범위가 제한적입니다.
UTF-8	각 Unicode code point를 1~4byte의 sequence로 나타냅니다.
UTF-7	UTF-8보다 7bit channel에서 더 효휼적으로 설계되었지만 보안과 견고함에서 문제점을 가지고 있으므로 UTF-7보다는 UTF-8을 더 권장합니다.
UTF-16	각 Unicode code point를 1~2개의 16bit integer로 표현합니다.
UTF-32	각 Unicode code point를 32bit integer로 표현하므로 가변 길이 encoding의 다른 Unicode encoding과는 달리 고정된 길이의 encoding입니다.
ANSI/ISO encodings	특정 언어 또는 언어의 group을 지원하기 위해 사용되는 다양한 code page에 대한 지원을 제공합니다.

현시점에 대부분의 system은 UTF-8을 기본으로 사용하고 있으며 .NET에서는 Encoding.Default로 나타낼 수 있습니다. 상술하였듯 Encoding.UTF7은 보안에 취약하므로 사용을 피해야 하며 이러한 이유로 C# compiler는 UTF-7 사용을 시도할 때 경고를 띄우고 있습니다. UTF-7은 다른 system과의 호환성을 위해 어쩔 수 없이 text를 encoding 해야 하는 경우를 위해서 선택적으로 사용할 수 있도록 남아있을 뿐입니다.

(1) Byte array로 문자열 encoding 하기

csStudy09 solution에서 WorkingWithEncodings이름의 project를 생성하고 Program.cs에서는 System.Text namespace를 import 한 뒤 사용자로 부터 선택된 encoding을 사용해 문자열을 encode 하는 문을 아래와 같이 작성합니다. 또한 각 byte는 loop를 통해 문자열로 decode 한 다음 이를 출력하도록 합니다.

WriteLine("Encodings");
WriteLine("[1] ASCII");
WriteLine("[2] UTF-7");
WriteLine("[3] UTF-8");
WriteLine("[4] UTF-16 (Unicode)");
WriteLine("[5] UTF-32");
WriteLine("[6] Latin1");
WriteLine("[any other key] Default encoding");
WriteLine();
            
Write("Press a number to choose an encoding.");
ConsoleKey number = ReadKey(intercept: true).Key;
WriteLine(); WriteLine();

Encoding encoder = number switch
{
    ConsoleKey.D1 or ConsoleKey.NumPad1 => Encoding.ASCII,
    ConsoleKey.D2 or ConsoleKey.NumPad2 => Encoding.UTF7,
    ConsoleKey.D3 or ConsoleKey.NumPad3 => Encoding.UTF8,
    ConsoleKey.D4 or ConsoleKey.NumPad4 => Encoding.Unicode,
    ConsoleKey.D5 or ConsoleKey.NumPㄴad5 => Encoding.UTF32,
    ConsoleKey.D6 or ConsoleKey.NumPad6 => Encoding.Latin1,
    _ => Encoding.Default
};

// encode할 문자열
string message = "Café £4.39";
WriteLine($"Text to encode: {message} Characters: {message.Length}");

// 문자열을 byte array로 encode
byte[] encoded = encoder.GetBytes(message);

// encode후 byte 확인
WriteLine("{0} used {1:N0} bytes.", encoder.GetType().Name,
encoded.Length);
WriteLine();

// 각 byte 열거
WriteLine($"BYTE | HEX | CHAR");
foreach (byte b in encoded)
{
    WriteLine($"{b,4} | {b.ToString("X"),3} | {(char)b,4}");
}

string decoded = encoder.GetString(encoded);
WriteLine(decoded);

예제를 실행하고 ASCII선택을 위해 1을 누르면 아래와 같이 결과를 확인할 수 있습니다. 표시된 byte결과를 보면 pound 기호 (£)와 accent e (é)는 ASCII로 표현되지 않았음을 확인할 수 있습니다. 따라서 이때는 ?문자가 대신 사용되었습니다.

다시 예제를 실행하고 이번에는 UTF-8인 3을 입력합니다. UTF-8에서는 위 두 문자를 위해 추가로 2 byte를 더 필요로 하지만(총 12byte) é 과 £ 문자에 대한 encode와 decode가 가능합니다.

UTF-16은 모든 문자에 대해 2byte를 필요로 하므로 총 20byte가 사용되며 é 와 £문자 역시 encode와 decode가 가능합니다. 해당 encoding은 .NET에서 내부적으로 char와 string값을 저장하기 위해 사용됩니다.

(2) File로 text를 encoding 하고 decoding 하기

StreamReader와 StreamWriter 같은 stream helper class를 사용할 때 사용하고자 하는 encoding을 지정할 수 있습니다. helper로 작성하면 text는 자동적으로 encoded 되며 helper로부터 읽으면 byte는 자동적으로 decode 됩니다.

Encoding을 지정하려면 helper type의 생성자로 두 번째 매개변수를 통해 encoding을 다음과 같이 전달합니다.

StreamReader reader = new(stream, Encoding.UTF8); 
StreamWriter writer = new(stream, Encoding.UTF8);

때로는 다른 system에서 사용할 file을 생성하기 때문에 어떤 encoding을 사용할지 선택할 수 없는 경우가 있습니다. 만약 이런 상황이라면 가장 적은 수의 byte를 사용하되 필요한 모든 문자를 저장할 수 있는 것을 선택해 보는 것이 도움이 될 수 있습니다.

4. Random access handle을 가지는 읽기 및 쓰기

.NET 6부터는 file stream이 없이도 file을 대상으로 작업이 가능한 새로운 API를 도입하였습니다.

이를 위해 우선 아래와 같이 file에 대한 handle을 가져와야 합니다.

using Microsoft.Win32.SafeHandles;
using System.Text;

using SafeFileHandle handle = File.OpenHandle(path: "test.txt", mode: FileMode.OpenOrCreate, access: FileAccess.ReadWrite);

이렇게 하고 나면 byte array로 encode 된 text를 읽기 전용 memory buffer에 아래와 같이 작성하고 이를 file로 저장할 수 있습니다.

ReadOnlyMemory<byte> buffer = new(Encoding.UTF8.GetBytes("test123123"));
await RandomAccess.WriteAsync(handle, buffer, fileOffset: 0);

file에서 읽기 위해서는 file의 길이(크기)를 가져와 해당 길이만큼의 공간을 memory buffer에 할당하여 file을 읽어 들입니다.

long length = RandomAccess.GetLength(handle);
Memory<byte> contentBytes = new(new byte[length]);
await RandomAccess.ReadAsync(handle, contentBytes, fileOffset: 0);

string content = Encoding.UTF8.GetString(contentBytes.ToArray());
WriteLine($"Content of file: {content}");

5. Object graph 직렬화

Object graph는 직접 참조 혹은 참조 chain을 통해 간접적으로 서로 연결된 다수의 개체입니다.

직렬화는 지정한 형식을 사용해 실제 object graph를 일련의 byte로 변환하는 처리를 말합니다.(역직렬화는 이런 처리를 반대로 수행합니다.) 직렬화를 통해 우리는 실제 개체의 현재 상태를 저장할 수 있으며 이후에 그 상태 그대로 개체를 다시 재생할 수 있습니다. 예를 들어 대표적으로 game을 들 수 있는데 현재 game의 진행상태를 저장함으로서 우리는 이후에 마지막상태에서 game을 계속 진행할 수 있습니다. 직렬화된 개체는 database나 file로 저장됩니다.

지정할 수 있는 format(형식)에는 수십 가지가 있지만 대부분의 경우 XML(eXtensible Markup Language)나 JSON(JavaScript Object Notation)이 둘 중 하나를 사용합니다.

JSON은 data를 상당히 소형화할 수 있는 것으로 web이나 mobile application에서 최적화되어 있습니다. XML은 JSON보다 훨씬 장황하며 주로 legacy system에서 지원되는 경우가 많습니다. 따라서 직렬화된 개체 graph의 크기를 최소화하려면 JSON을 사용하는 것이 좋습니다. JSON은 태생적으로 JavaScript를 위한 직렬화형식이므로 개체 graph를 web이나 mobile application으로 전송하기에도 적합한 형식이라 할 수 있습니다. mobile app은 대게 제한된 대역폭환경에서 동작하는 경우가 많으므로 byte의 수는 중요한 요소로 작용합니다.

.NET은 XML과 JSON으로 직렬화하고 그 반대를 수행할 수 있는 다수의 class를 가지고 있는데, 그중 XmlSerializer와 JsonSerializer가 가장 대표적인 class에 해당합니다.

(1) XML 직렬화

일반적으로 가장 많이 사용되는 직렬화 형식 중 하나가 바로 XML입니다. 일반적인 예제를 만들어 보기 위해 csStudy09 solution에서 WorkingWithSerialization이름의 project를 생성하고 자체 혹은 파생된 class에서만 접근할 수 있는 protected속성인 Group으로 Student.cs이름의 class file를 아래와 같이 생성합니다.

public class Student
{
    public Student(int group)
    {
        Group = group;
    }

    public string? Name { get; set; }
    public DateTime DateOfBirth { get; set; }
    public HashSet<Student>? Friends { get; set; }
    protected int Group { get; set; }
}

예제에서는 초기 salary값을 설정하기 위해 단일 매개변수를 가진 생성자를 사용하고 있습니다. Program.cs에서는 기존의 문을 모두 삭제하고 XML 직렬화에 필요한 정적 Environment와 Path namespace를 import 합니다.

using static System.Environment;
using static System.IO.Path;

그리고 Student instance의 개체 graph를 생성하는 문을 아래와 같이 추가해 줍니다.

List<Student> students = new()
{
    new(1)
    {
        Name = "홍길동",
        DateOfBirth = new(year: 2014, month: 9, day: 14)
    },
    new(2)
    {
        Name = "홍길영",
        DateOfBirth = new(year: 2014, month: 6, day: 29)
    },
    new(3)
    {
        Name = "장진구",
        DateOfBirth = new(year: 2014, month: 3, day: 7),
        Friends = new()
        {
            new(4)
            {
                Name = "김말순",
                DateOfBirth = new(year: 2014, month: 7, day: 7)
            }
        }
    }
};

// Person의 List를 XML로 형식화할 개체 생성
XmlSerializer xs = new(type: students.GetType());
            
// 작성할 file생성
string path = Combine(CurrentDirectory, "students.xml");
using (FileStream stream = File.Create(path))
{
    // 개체 graph를 stream으로 직렬화
    xs.Serialize(stream, students);
}

Console.WriteLine("Written {0:N0} bytes of XML to {1}", arg0: new FileInfo(path).Length, arg1: path);
Console.WriteLine();
            
Console.WriteLine(File.ReadAllText(path));

예제를 실행하면 아마도 다음과 같은 결과를 표시할 것입니다.

위 오류를 해결하기 위해서는 Student.cs에서 매개변수 없는 생성자를 아래와 같이 추가해줘야 합니다.

public Student() { }

사실 위 생성자는 어디에서도 사용되지 않지만 반드시 존재해야 XmlSerializer가 새로운 Student instance를 역직렬화 처리 중에 호출할 수 있습니다.

예제를 실행하고 결과를 확인해 봅니다.

결과에서는 '<Name>홍길동</Name>'과 같이 XML요소로 개체 graph가 직렬화되었으며 Group속성은 public속성이 아니기에 포함되지 않았습니다.

(2) XML 경량화하기

예제에서 일부 field는 요소대신 attribute를 사용해 더욱 경량화할 수 있습니다.

Student.cs에서 System.Xml.Serialization namespace를 import한뒤

using System.Xml.Serialization;

Name, DateOfBirth속성에 해당 [XmlAttribute] attribute를 적용합니다. 이때 각 attribute에 아래와 같이 줄임말을 적용합니다.

[XmlAttribute("nm")]
public string? Name { get; set; }

[XmlAttribute("dob")]
public DateTime DateOfBirth { get; set; }

위와 같이 적용 후 다시 예제를 실행하면 설정한 줄임말이 사용됨으로써 file공간이 절약됨을 알 수 있습니다. 따라서 생성된 file의 용량이 이전보다 더 줄어들게 됩니다.

(3) XML file 역직렬화

Memory에 실제 개체로 XML file을 역직렬화하기 위해 Program.cs에서 XML file을 열고 역직렬화하는 문을 아래와 같이 작성합니다.

Console.WriteLine();
Console.WriteLine("* Deserializing XML files");

string path = Combine(CurrentDirectory, "students.xml");

List<Student> students = new();
XmlSerializer xs = new(type: students.GetType());

using (FileStream xmlLoad = File.Open(path, FileMode.Open))
{
    List<Student>? loadedStudent = xs.Deserialize(xmlLoad) as List<Student>;
    if (loadedStudent is not null)
    {
        foreach (Student p in loadedStudent)
        {
            Console.WriteLine("{0} has {1} children.", p.Name, p.Friends?.Count ?? 0);
        }
    }
}

위 예제를 실행하면 XML로부터 student개체를 load 하여 아래와 같이 열거할 것입니다.

이 외에도 XML을 생성하는 데 사용할 수 있는 다른 많은 attribute들도 존재합니다.

만약 어떠한 annotation도 사용하지 않는다면 XmlSerializer는 역직렬화에서 속성의 이름에 대소문자를 구분하지 않고 수행합니다.

XmlSerializer를 사용할 때 오로지 public field와 속성만을 포함하며 type은 반드시 매개변수 없는 생성자를 가져야 합니다. 또한 attribute를 사용해 출력을 사용자정의할 수 있습니다.

(4) JSON 직렬화

Newtonsoft.Json는 Json.NET으로 알려져 있으며 JSON 직렬화에 사용할 수 있는 가장 인기 있고 강력한 .NET library 중 하나입니다.

NuGet package manager에서 download를 counter 하는 데 사용되는 단위는 32bit integer인데 Newtonsoft.Json의 인기가 너무 높은 나머지 여기서 수용가능한 숫자의 범위를 넘어설 정도의 download횟수가 기록된 적도 있을 정도입니다.

Json.NET을 사용하기 위해 우선 Nuget Package에서 아래와 같이 Newtonsoft.Json을 검색해 최신 version을 내려받습니다.

그리고 Program.cs에서 text file을 생성하고 file에 JSON으로 student를 직렬화하는 구문을 아래와 같이 추가합니다.

List<Student> students = new()
{
    new(1)
    {
        Name = "홍길동",
        DateOfBirth = new(year: 2014, month: 9, day: 14)
    },
    new(2)
    {
        Name = "홍길영",
        DateOfBirth = new(year: 2014, month: 6, day: 29)
    },
    new(3)
    {
        Name = "장진구",
        DateOfBirth = new(year: 2014, month: 3, day: 7),
        Friends = new()
        {
            new(4)
            {
                Name = "김말순",
                DateOfBirth = new(year: 2014, month: 7, day: 7)
            }
        }
    }
};

string jsonPath = Combine(CurrentDirectory, "student.json");
using (StreamWriter jsonStream = File.CreateText(jsonPath))
{
    Newtonsoft.Json.JsonSerializer jss = new();
    jss.Serialize(jsonStream, students);
}

Console.WriteLine();
Console.WriteLine("Written {0:N0} bytes of JSON to: {1}", arg0: new FileInfo(jsonPath).Length, arg1: jsonPath);

Console.WriteLine(File.ReadAllText(jsonPath));

예제를 실행해 보면 JSON은 요소로 이루어진 XML에 비해 byte의 수가 절반도 안 되는 훨씬 적은 용량만이 필요함을 알 수 있습니다. 심지어 attribute를 사용한 XML에 비해서도 더 작은 용량입니다.

(5) 고성능 JSON 처리

.NET Core 3.0은 JSON처리에 필요한 새로운 namespace인 System.Text.Json를 추가하였으며 Span와 같은 API를 사용하여 성능에 최적화하였습니다.

Json.NET과 같은 이전 library는 UTF-16을 읽음으로써 구현되는데 HTTP를 포함한 대부분의 network protocol이 UTF-8을 사용하고 Json.NET의 Unicode 문자열 값으로 부터 UTF-8로 변환하는 것을 피할 수 있기 때문에 UTF-8을 사용하여 JSON문서를 읽고 쓰는 것이 더 성능이 좋다고 할 수 있습니다.

Micorsoft는 이 새로운 API를 통해 상황에 따라 1.3 ~ 5배까지 성능향상을 달성했습니다.

본래 Json.NET의 제작자인 James Newton-King은 그가 JSON API에 관한 comment에서 'Json.NET은 사라지지 않는다.'라고 언급한 것처럼 Microsoft와 협업하여 새로운 JSON type을 개발하였습니다.

JSON type을 역직렬화하는데 새로운 JSON API를 사용하기 위해 WorkingWithSerialization project의 Program.cs상단에서 직렬화를 수행하기 위한 새로운 JSON class를 별칭을 사용해 Import 합니다. 별칭은 위에서 사용한 Json.NET의 이름과 충돌하는 것을 피하기 위한 것입니다.

using FastJson = System.Text.Json.JsonSerializer;

그리고 JSON file을 열어 역직렬화를 수행한 뒤 Student에 대한 frends의 이름과 수를 출력하도록 하는 문을 아래와 같이 작성합니다.

string jsonPath = Combine(CurrentDirectory, "student.json");

using (FileStream jsonLoad = File.Open(jsonPath, FileMode.Open))
{
	// deserialize object graph into a List of Person
	List<Student>? loadedStudent = await FastJson.DeserializeAsync(utf8Json: jsonLoad, returnType: typeof(List<Student>)) as List<Student>;

	if (loadedStudent is not null)
	{
		foreach (Student s in loadedStudent)
		{
			Console.WriteLine("{0} has {1} children.", s.Name, s.Friends?.Count ?? 0);
		}
	}
}

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

개발 생산성을 위해서는 Json.NET을, 다양한 기능 또는 성능을 위해서는 System.Text.Json을 사용합니다. 아래 link를 통해 이 둘에 대한 차이목록을 확인해 볼 수 있습니다.

Migrate from Newtonsoft.Json to System.Text.Json - .NET | Microsoft Learn

Migrate from Newtonsoft.Json to System.Text.Json - .NET

Learn about the differences between Newtonsoft.Json and System.Text.Json and how to migrate to System.Text.Json.

learn.microsoft.com

(6) JSON 처리 제어

JSON처리 방식에 관해서는 아래와 같이 사용가능한 많은 option들이 존재합니다.

Field의 포함 또는 제외
Casing 정책 설정
대소문자 구분 정책 설정
공백의 처리방식 설정

예제를 위해 csStudy09 solution에서 WorkingWithJson이름의 project를 생성한 뒤 Program.cs에서 기존의 문을 모두 삭제하고 고성능 JSON을 위한 주요 namespace와 System. Environment, System.IO.Path namespace를 정적 import 합니다.

using System.Text.Json; 

using static System.Environment;
using static System.IO.Path;

그다음 Book.cs이라는 새로운 class file을 추가하고 그 안에 Book class를 아래와 같이 정의합니다.

using System.Text.Json.Serialization;

namespace WorkingWithJson
{
	public class Book
	{
		public Book(string title)
		{
			Title = title;
		}

		public string Title { get; set; }

		public string? Author { get; set; }
		
		[JsonInclude]
		public DateTime PublishDate;

		[JsonInclude]
		public DateTimeOffset Created;

		public ushort Pages;
	}
}

다시 Program.cs로 돌아와 Book class의 instance를 생성하고 이를 JSON으로 직렬화하는 문을 아래와 같이 작성합니다.

Book mybook = new(title: "어린왕자")
{
	Author = "생텍쥐페리",
	PublishDate = new(year: 1943, month: 4, day: 6),
	Pages = 250,
	Created = DateTimeOffset.UtcNow,
};

JsonSerializerOptions options = new()
{
	IncludeFields = true, // 모든 field를 포함
	PropertyNameCaseInsensitive = true,
	WriteIndented = true,
	PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
	Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
};

string filePath = Combine(CurrentDirectory, "mybook.json");

using (Stream fileStream = File.Create(filePath))
{
	JsonSerializer.Serialize<Book>(utf8Json: fileStream, value: mybook, options);
}

Console.WriteLine("{0:N0} byte의 JSON file {1}", arg0: new FileInfo(filePath).Length, arg1: Path.GetFileName(filePath));
Console.WriteLine();
			
Console.WriteLine(File.ReadAllText(filePath));

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

생성된 JSON file은 총 171byte로 member의 이름은 publishDate와 같이 camelCase가 적용되었습니다. 이는 Javascript를 사용하는 browser를 위한 가장 적합한 방식입니다. 또한 option설정에서 pages를 포함하여 모든 field를 포함하도록 했고 결과를 보면 사람이 읽기 쉽도록 하기 위해 JSON자체에 들여 쓰기 등의 서식이 적용되어 있음을 확인할 수 있습니다. DateTime와 DateTimeOffset값은 단일 표준 문자열 값으로 저장됩니다.

Program.cs에서 JsonSerializerOptions을 설정할 때 PropertNameCaseInsensitive, WriteIndented와 IncludeFields부분을 주서처리하고 예제를 다시 실행해 보면 결과를 다음과 같이 바뀌게 됩니다.

결과를 보면 JSON은 133byte가 되어 이전 171byte보다 용량이 작아졌으며 member의 이름은 normal casing가 사용되어 PublishDate와 같이 되었습니다. Pages field는 포함되지 않았으며 [JsonInclude]와 같은 attribute가 포함된 field는 정상적으로 포함되었습니다.

(7) HTTP응답을 위한 새로운 JSON 확장 method

.NET 5에서 Microsoft는 HttpResponse의 확장 method와 같이 System.Text.Json namespace type을 개선하였습니다.

(8) Newtonsoft에서 신규 JSON으로의 변환

만약 Newtonsoft Json.NET library를 사용하는 code를 신규 System.Text.Json namespace로 변환해야 한다면 아래 link에서 Microsoft가 이를 위해 마련해 둔 문서를 찾아볼 수 있습니다.

Migrate from Newtonsoft.Json to System.Text.Json - .NET | Microsoft Learn

Migrate from Newtonsoft.Json to System.Text.Json - .NET

Learn about the differences between Newtonsoft.Json and System.Text.Json and how to migrate to System.Text.Json.

learn.microsoft.com

6. 환경변수

환경변수는 system및 사용자 정의가능한 값이며 이는 process의 동작을 실행하는 방식에 영향을 줄 수 있습니다. 일반적으로는 ASP.NET Core project에서 개발과 production 설정사이를 전환하기 위한 설정에 사용하거나 database연결 문자열에서 service key와 password같이 process에서 필요한 값을 전달하는데 사용됩니다.

Windows에서 환경변수는 machine(system), user, process라는 3가지 범위에서 설정할 수 있습니다. 환경변수를 가져오거나 설정하는 method는 기본적으로 process의 범위 수준을 가정하며 process, user, machine의 EnvironmentVariableTarget을 지정하는 override를 가집니다.

GetEnvironmentVariables	지정된 수준의 범위 혹은 현재 process에 대한 모든 환경변수의 IDictionary를 반환합니다.
GetEnvironmentVariable	명몇된 환경변수의 값을 반환합니다.
SetEnvironmentVariable	명명된 환경변수의 값을 설정합니다.
ExpandEnvironmentVariables	문자열로 구성된 모든 환경변수, 예를 들어 "Computer name : %COMPUTER_NAME%"에서와 같은 값에서 %%를 해당 식별되는 값으로 변환합니다.

(1) 모든 환경 변수 가져오기

예제를 통해 다양한 범위 수준에서 현재 환경변수를 어떻게 확인할 수 있는지 확인해 보겠습니다. Program.cs를 아래와 같이 작성합니다.

using System.Collections;
using static System.Environment;

IDictionary evs = GetEnvironmentVariables();
IDictionary evm = GetEnvironmentVariables(EnvironmentVariableTarget.Machine);
IDictionary evu = GetEnvironmentVariables(EnvironmentVariableTarget.User);

foreach (var key in evs.Keys)
{
    Console.WriteLine("key : {0}, value : {1}", key, evs[key]!.ToString());
}

Console.WriteLine("-------------------------------------------------------");

foreach (var key in evm.Keys)
{
    Console.WriteLine("key : {0}, value : {1}", key, evs[key]!.ToString());
}

Console.WriteLine("-------------------------------------------------------");

foreach (var key in evu.Keys)
{
    Console.WriteLine("key : {0}, value : {1}", key, evs[key]!.ToString());
}

위 예제는 각각의 범위에 속한 모든 환경변수를 표시하도록 합니다.

(2) 환경변수를 확장하고 설정하고 가져오기

어떤 경우는 내장된 환경변수를 포함하고 있는 문자열을 형식화하여 표시해야 하는 경우가 있을 수 있습니다. 이러한 경우 환경변수는 %문자로 변수를 감싸는 형태로 표시됩니다.

"User : %USERNAME%, Computer : %COMPUTER_NAME%"

필요하다면 환경변수는 Windows상에서 set 혹은 setx 명령을 통해 설정할 수 있습니다.

변수 범위	예제
Session/Shell	set MY_TMP_VAR="me"
User	setx MY_TMP_VAR "me"
Machine	setx MY_TMP_VAR "me" /M

set 명령은 임시 환경변수를 정의하는 것으로 즉시 값을 다시 읽거나 현재 shell 또는 session안에서 읽을 수 있습니다. 다만 해당 범위의 값을 설정할때는 위 표에서 처럼 =문자를 사용해 값을 할당함에 주의해야 합니다.

setx 명령은 영구적인 환경변수를 설정하지만 현재 shell 또는 session을 닫고 재시작해야만 해당 환경변수를 읽을 수 있습니다. 또한 이 명령에서는 값의 할당을 위해 =문자를 사용하지 않음에 주의해야 합니다.

setx명령에 관한 좀더 자세한 사항은 아래 link를 참고해 주시기 바랍니다.

setx | Microsoft Learn

setx

Reference article for the setx command, which creates or modifies environment variables in the user or system environment, without requiring programming or scripting.

learn.microsoft.com

또한 환경변수는 Windows상에서 Settings -> System -> About -> Advanced system settings -> System Properties 순서로 이동하면 해당 화면을 통해 변수항목과 해당 값을 확인할 수 있습니다.

임시적으로 환경변수를 설정하는 것은 아래와 같이 export 명령으로도 가능합니다.

export MY_TMP_VAR=me

export 명령에 대한 자세한 사항은 아래 link를 참고하시기 바랍니다.

export Man Page - Linux - SS64.com

Set an environment variable. The supplied names are marked for automatic export to the environment of subsequently executed commands. If no names are supplied, or if the '-p' option is given, a list of exported names is displayed. To view the environment v

ss64.com

위 예제에서 알아본 방법외에 환경변수를 설정하고 값을 확인하고 확장하는 또 다른 방법이 존재하며 이를 예제를 통해 알아보도록 하겠습니다.

Program.cs에서 환경변수를 포함하고 있는 문자열을 정의한 뒤 이에 대한 값을 출력하도록 아래와 같이 code를 작성합니다.

string comUser = "User name : %USERNAME%, Computer name : %COMPUTERNAME%";

Console.WriteLine(ExpandEnvironmentVariables(comUser));

이번에는 MY_TMP_VAR 이름의 환경변수를 process범위로 설정하고 해당 값을 출력하도록 합니다.

string tmpKey = "MY_TMP_VAR";
SetEnvironmentVariable(tmpKey, "cliel");
string? tmpResult = GetEnvironmentVariable(tmpKey);

Console.WriteLine($"{tmpKey}: {tmpResult}");

이번에는 MY_TMP_VAR 환경변수를 3개의 모든 범위수준에서 읽어오도록 program.cs를 아래와 같이 변경합니다.

string tmpKey = "MY_TMP_VAR";

string tmpValue = GetEnvironmentVariable(tmpKey, EnvironmentVariableTarget.Machine);
Console.WriteLine($"Machine - {tmpKey}: {tmpValue}");

tmpValue = GetEnvironmentVariable(tmpKey, EnvironmentVariableTarget.User);
Console.WriteLine($"User - {tmpKey}: {tmpValue}");

tmpValue = GetEnvironmentVariable(tmpKey, EnvironmentVariableTarget.Process);
Console.WriteLine($"Process - {tmpKey}: {tmpValue}");

그런다음 project folder에서 다음과 같이 launchSettings.json file을 생성합니다.

{
    "profiles": {
        "test": {
            "commandName": "Project",
            "environmentVariables": 
            {
                "MY_TMP_VAR": "me"
            }
        }
    }
}

여기서 test는 project 이름입니다.

terminal이나 command창에서는 다음 명령을 통해 user와 machine 두 범위에서 같은 이름의 환경변수를 설정합니다.

setx MY_TMP_VAR "me1"
setx MY_TMP_VAR "tmp2" /M

권한관련 오류가 발생되는 경우 terminal을 관리자 권한으로 실행시켜야 합니다.

예제를 실행시켜 다음과 같은 결과를 확인합니다.

결과를 통해 알 수 있듯이 launchSettings. json file에서의 설정은 process 수준으로 설정됩니다.

[C# 12와 .NET 8] 8. 공용 .NET Type

클리엘 — Fri, 23 Feb 2024 12:09:55 +0900

.NET에는 일반적인 개발과정에서 사용할 수 있는 숫자, 문자열, collection등과 span, index, range와의 작업, network access 등 몇 가지 공용 type들을 포함하고 있습니다.

1. 숫자 다루기

Data에 관한 가장 일반적인 작업중 하나가 바로 숫자입니다. 아래표는 .NET에서 숫자에 관한 가장 일반적인 type을 나타내고 있습니다.

Namespace	Example Type	Description
System	SByte, Int16, Int32, Int64	정수로서 음수, 양수, 0
System	Byte, UInt16, UInt32, UInt64	기수로서 0, 양수 / 부호가 없으므로 U로 표현
System	Half, Single, Double	실수로서, 부동소수점 수
System	Decimal	실수(accurate real)로서 과학, 공학, 금융분야에서 사용
System.Numbers	BigInteger, Complex, Quaternion	임의의 큰 정수, 복소수, 4차원

.NET은 .NET Framework 1.0부터 32bit float과 64bit double type을 지원해 왔습니다. IEEE 754 명세는 또한 16bit floating-point 표준을 정의하였는데 Machine learning의 일부 algorithm에서 해당 type을 필요로 하므로 Microsoft는 System.Half type을 .NET 5부터 포함하였으며 .NET 7부터는 System.Int128와 System.UInt128 type을 포함하였습니다.

현재 C#언어는 half와 Int128, UInt128에 대한 별칭을 따로 정의하지 않았으므로 System.Half와 System.Int128, Sysem.UInt128을 그대로 사용해야 합니다.

(1) Big integer 사용

C# 별칭이 있는 .NET type에서 저장가능한 가장 큰 정수는 18조 5천억으로 unsigned ulong integer입니다. 만약 이것보다 더 큰 수를 저장해야 한다면 BigInteger를 사용해야 합니다.

Visual Studio에서 csStudy08 solution을 만들고 여기에 WorkingWithNumbers이름의 Console App project를 추가합니다. 그런 뒤 Program.cs에서 기존구문을 모두 삭제하고 ulong type의 최댓값과 BigInteger를 통해 30 자릿수의 표시하는 문을 아래와 같이 추가합니다.

using System.Numerics;

ulong big = ulong.MaxValue;
Console.WriteLine($"{big,40:N0}");

BigInteger bigger = BigInteger.Parse("123456789012345678901234567890");
Console.WriteLine($"{bigger,40:N0}");

예제에서 사용한 format code 40은 오른쪽으로 40자리수 만큼 정렬하고자 하는 것이므로 두 숫자 모두 오른쪽 가장자리로 줄지어 표시하게 되며 N0은 천 단위 분리자와 소수점 0자리 사용을 의미합니다.

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

(2) 복소수 사용

복소수는 a + bi로 표현될 수 있으며 이때 a와 b는 실수, i는 허수 단위이고 여기서 i² = -1입니다. 실수부 a가 0이면 순허수, 허수부 b가 0이면 이것은 실수입니다.

복소수는 많은 STEM(science, technology, engineering and mathematics)연구분야에서 실질적으로 응용되고 있으며 가수의 실수와 허수 부분이 별도로 더해짐으로써 추가되었습니다.

(a + bi) + (c + di) = (a + c) + (b + d)i

WorkingWithNumbers project의 Program.cs에서 아래와 같이 2개의 복소수를 더하는 문을 추가합니다.

Complex c1 = new(real: 4, imaginary: 2);
Complex c2 = new(real: 3, imaginary: 7);
Complex c3 = c1 + c2;

Console.WriteLine($"{c1} added to {c2} is {c3}");
Console.WriteLine("{0} + {1}i added to {2} + {3}i is {4} + {5}i", c1.Real, c1.Imaginary, c2.Real, c2.Imaginary, c3.Real, c3.Imaginary);

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

..NET 6이전에는 (4, 2)와 (3, 7)을 더하면 (7, 9)가 되는 다른 형식을 사용했지만 .NET 7이후부터는 꺽쇠 괄호와 semi-colon을 사용하는 다른 기본형식을 사용합니다. 이는 일부 문화권에서 음수를 나타내기 위해 괄호를 사용하고 십진수를 나타내기 위해 commna를 사용하기 때문입니다.

(3) Quaternion(4원수)

Quaternions은 복소수를 확장자는 숫자체계로서 실수를 넘어 4차원 연관 규범 분할 대수를 형성하며 따라서 domain도 형성합니다. 사실 실제 활용해야 할 상황이 아니라면 이런 내용들에 대한 자세한 이해할 필요는 없는데, 이들은 공간을 묘사하는 데 사용되며 따라서 다수의 computer simulation과 비행 제어 system, video game engine에서 많이 사용되고 있습니다.

(4) 난수 생성

난수가 필요하지 않다면 Random class의 instance는 아래와 같이 생성할 수 있습니다.

Random r = new();

Random class는 난수 생성의 초기화에 사용되는 seed 값을 지정하는 매개변수를 가지고 있습니다.

Random r = new(Seed: 46378);

아래 글에서 언급하였지만

[.NET/C#] - [C# 12와 .NET 8] 2. C#

[C# 12와 .NET 8] 2. C#

이번 글에서는 C# programming 언어에 대한 기본적인 사항을 살펴볼 것입니다. 전반적으로 알아야 할 용어와 C#에 대한 기본적인 문법에 대한 것들입니다. 1. C# 언어 C#을 통해 application에 대한 source co

lab.cliel.com

매개변수의 이름은 camel case로 사용하길 권장하고 있습니다. 하지만 예제에서 보듯 해당 class의 생성자를 정의한 개발자가 해당 규칙을 어기는 바람에 seed가 아닌 Seed로 사용되고 있습니다. 다시 말하지만 Seed가 아닌 seed가 되어야 합니다.

Memory를 더 할당하지 않기 위해 .NET 6에서는 Random의 공유 정적 instance를 포함하고 있습니다.

Random r = Random.Shared;

일단 Random 개체를 생성하게 되면 임의의 숫자를 생성하는 method를 아래와 같이 호출할 수 있습니다.

int ranInt = r.Next(minValue: 1, maxValue: 7); // 1에서 6사이값
double randomReal = r.NextDouble(); // 0.0에서 1.0보다 작은값
byte[] arrayOfBytes = new byte[256];
r.NextBytes(arrayOfBytes); //256 random byte array

Random class는 random숫자를 생성하기 위해 일반적으로 사용되는 다음의 method를 갖고 있습니다.

Next	Next method는 minValue와 maxValue 2개의 매개변수를 필요로 합니다. 다만 이때 maxValue값은 method가 반환하는 최댓값을 의미하는 것이 아님에 주의해야 합니다. 이는 'exclusive upper bound(배타적 상한선)'라고 하는 것으로 반환하는 최댓값보다 1 더 많아야 함을 의미합니다.
NextDouble	0.0보다 더 크거나 같으면서 1.0미만의 수를 반환합니다. float type의 값이 필요하다면 NextSingle method를 대신 사용할 수 있습니다.
NextBytes	random byte (0 to 255)값으로 array를 채우는 method로서 00~FF와 같이 16진수로서 byte값을 형식화 하기 위해 사용됩니다.

암호화와 같이 진정한 random값이 필요한 경우를 위해 RandomNumberGenerator와 같은 특별한 type을 사용할 수 있습니다.

.NET 8에서는 다음과 같은 2개의 새로운 method를 포함하였습니다.

GetItems<T, length>	해당 method에는 Type T에 대한 배열 혹은 읽기 전용 span과 생성하고자 하는 item의 수가 전달되며 이것으로 부터 ramdom하게 선택된 item을 반환합니다.
Shuffle<T>	해당 method에는 Type T에 대한 배열 혹은 일기 전용 span이 전달되며 해당 item의 순서가 ramdom하게 변경됩니다.

Random r = Random.Shared;

string[] employees = r.GetItems(
    choices: new[] { "lee", "choi", "kim", "hong" },
    length: 3);

foreach (string employee in employees)
    Console.Write($" {employee}");

Console.WriteLine();

r.Shuffle(employees);

foreach (string emploee in employees)
    Console.Write($" {emploee}");

(5) GUID 생성

GUID (globally unique identifier)는 128bit TEXT 문자열로서 중복되지 않는 고유한 값을 나타냅니다. 따라서 multi-tasking환경에서의 충돌을 방지하는 것과 같은 상황에서 사용될 수 있습니다.

System.Guid type은 값 type(구조체)로서 NewGuid method로 새로운 GUID값을 나타내며 기존 값을 문자열로서 나타내기 위한 Parse와 ParseTry method를 갖추고 있고 그 반대로 문자열을 GUID로 변환하기도 합니다.

예제를 위해 아래와 같이 NewGuid method로 GUID값을 생성하고 그 값을 byte array로 나타내기 위한 문을 아래와 같이 작성합니다.

Guid g = Guid.NewGuid();
Console.WriteLine($"Random GUID: {g}.");

byte[] guidAsBytes = g.ToByteArray();

Console.Write("GUID to byte array: ");
for (int i = 0; i < guidAsBytes.Length; i++)
    Console.Write($"{guidAsBytes[i]:X2} ");

예제를 실행하면 아래와 같이 표시할 것입니다. NewGuid method는 random한 값을 생성합니다.

2. Text

Text는 변수를 통해 사용되는 가장 일반적인 data type이라고 할 수 있습니다. 아래 표는 text와 관련된 .NET의 일반적인 type을 나타내고 있습니다.

Namespace	Type	Description
System	Char	단일 한문자
System	String	text
System.Text	StringBuilder	고성능 문자열 다루기
System.Text.RegularExpressions	Regex	고성능 문자열 pattern-matching

(1) 문자열 길이 확인하기

Text를 다루게 되는 경우 사용되는 몇 가지 일반적인 상황들이 있습니다. 예를 들어 string변수에 저장된 문자열의 길이를 알아내는 경우 등이 그것입니다.

csStudy08 solution에 WorkingWithText console app project를 추가하고 Program.cs에서 기본의 문을 모두 삭제한 뒤 도시 이름을 저장하기 위한 변수를 정의하고 console을 통해 도시이름과 길이를 출력하는 문을 아래와 같이 작성합니다.

string city = "Seoul";
Console.WriteLine($"{city} is {city.Length} characters long.");

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

(2) 문자열에서 문자 확인하기

String class는 문자열을 저장하기 위해 내부적으로 문자에 대한 array를 사용하며 또한 한문자를 읽기 위해 array 구문을 사용할 수 있는 indexer를 가지고 있습니다. Array indexer는 0부터 시작하므로 세 번째 문자라면 index는 2가 됩니다.

Program.cs에서 string변수의 첫 번째 문자와 네 번째 문자를 표시하는 문을 아래와 같이 작성합니다.

Console.WriteLine($"First char is {city[0]} and fourth is {city[3]}.");

예제를 실행하면 다음과 같은 결과를 표시합니다.

(3) 문자열 분할

문자열은 문자열 안에서 특정 문자(이를 테면 comma(,)와 같은)를 기준으로 array형태의 분리가 가능합니다.

Program.cs에서 comma로 분리된 도시이름을 포함한 단일 문자열 변수를 정의하고 이를 Split method를 통해 분리하는 문을 추가합니다. 이때 분리의 기준을 comma로 지정하며 반환된 문자열값의 array를 열거하도록 합니다.

string cities = "Seoul,Busan,Daegu,Daejeon,Jeju";
string[] citiesArray = cities.Split(',');

Console.WriteLine($"There are {citiesArray.Length} items in the array:");

foreach (string item in citiesArray)
{
    Console.WriteLine(item);
}

예제를 실행하면 다음과 같은 결과를 볼 수 있습니다.

(4) 문자열의 일부 가져오기

문자열의 일부를 가져오는 방법 중의 하나로 IndexOf method를 사용할 수 있습니다. 해당 method는 문자열 안에서 지정한 문자 또는 문자열에 대한 index위치를 반환하는 9개의 overload를 가지고 있습니다.

Substring method는 2개의 다음과 같은 2개의 overload를 가집니다.

Substring(startIndex, length) : startIndex로 시작하고 다음 length 문자만큼을 포함하는 문자열의 일부를 반환합니다.
Substring(startIndex) : startIndex로 시작하고 그다음 끝까지 모든 문자열을 포함하는 문자열의 일부를 반환합니다.

Program.cs에서 사람의 이름을 저장하는 string변수를 추가합니다. 이때 성과 이름은 공백으로 구분합니다. 그리고 해당 공백의 위치를 찾아 성과 이름을 분리하며 다른 순서로도 재결합될 수 있도록 합니다.

string fullName = "hong seojun";
int indexOfTheSpace = fullName.IndexOf(' ');

string firstName = fullName.Substring(startIndex: 0, length: indexOfTheSpace);
string lastName = fullName.Substring(startIndex: indexOfTheSpace + 1);

Console.WriteLine($"Original: {fullName}");
Console.WriteLine($"Swapped: {lastName}, {firstName}");

예제를 실행하면 다음 결과를 볼 수 있습니다.

(5) 내용에서 문자열 확인

문자열에서는 특정 문자열로 시작하는지 혹은 끝나는지, 아니면 어떤 문자열을 포함하고 있는지를 확인할 수 있습니다.

Program.cs에서 문자열 저장을 위한 string변수를 추가하고 특정 문자열로 시작하는지와 포함하는지를 확인하는 문을 아래와 같이 작성합니다.

string company = "Microsoft";
bool startsWithM = company.StartsWith("M");
bool containsN = company.Contains("N");

Console.WriteLine($"Text: {company}");
Console.WriteLine($"Starts with M: {startsWithM}, contains an N: {containsN}");

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

(6) 문자열 비교

문자열 비교 역시 문자열을 통한 가장 일반적인 작업에 해당합니다. 예를 들어 login해야 하는 사용자가 자신의 ID와 비밀번호를 입력했다면 이것을 저장된 것과 비교해야할 필요가 있습니다.

string class는 IComparable interface를 구현하고 있으므로 CompareTo instance method를 통해 문자열을 비교할 수 있고 이때 문자열 값이 더 큰지, 같은지, 아니면 더 작은지에 따라 method는 -1, 0, 1의 값을 반환하게 됩니다. IComparable interface는 이미 아래 글에게 다루어본바 있습니다.

[.NET/C#] - [C# 12와 .NET 8] 6. Interface와 Class상속

[C# 12와 .NET 8] 6. Interface와 Class상속

이번 글을 통해서는 OOP(Object-Oriented Programming)을 사용한 하나의 개체에서 다른 새로운 type을 상속하는 기본 개념에 대해 알아볼 것입니다. 또한 generic을 사용하여 어떻게 code를 안전하게 만들고

lab.cliel.com

다만 영문 대소문자는 순서에 영향을 줄 수 있고 문자열의 순서규칙은 문화권에 영향을 받습니다. 예를 들어 이중 L은 Spain어에서 하나의 문자로 취급됩니다.

일관성을 위해 때로는 문화권에 영향을 받지 않는 방식으로 비교를 수행해야할 필요가 있으며 이때 Compare라는 정적 method를 사용할 수 있습니다.

using System.Globalization;

Console.OutputEncoding = System.Text.Encoding.UTF8;
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US");

string text1 = "abc";
string text2 = "ABC";

Console.WriteLine($"문자열1: {text1}, 문자열2: {text2}");
Console.WriteLine("비교: {0}.", string.Compare(text1, text2));
Console.WriteLine("비교 (대소문자 무시): {0}.", string.Compare(text1, text2, ignoreCase: true));
Console.WriteLine("비교 (문화권및 대소문자 무시): {0}.", string.Compare(text1, text2, StringComparison.InvariantCultureIgnoreCase));

소문자 a는 대문자 A보다 더 작게 판단되므로 비교 결과가 -1이 되지만 대소문자를 무시하도록 하면 또는 더 확실하게 대소문자와 문화권을 무시하도록 설정하면 2개의 문자열을 동등하게 비교할 수 있습니다.

문자열 비교에 관해서는 아래 link를 참고하시기 바랍니다.

Collation, sorting, and string comparison - Globalization | Microsoft Learn

Collation, sorting, and string comparison - Globalization

In world-ready applications, the alphabetical order can vary among languages, and the conventions for sequencing items can also be quite different.

learn.microsoft.com

(7) 문자열 결합, 형식화 그리고 기타

아래 표에서는 string에서 사용할 수 있는 몇 가지 member를 나타내고 있습니다.

Member	Description
Trim, TrimStart, TrimEnd	해당 method는 space나 tab 그리고 carriage return과 같은 공백문자를 제거합니다.
ToUpper, ToLower	대상 문자열을 전부 대문자 혹은 소문자로 변환합니다.
Insert, Remove	특정 문자열을 삽입하거나 제거합니다.
Replace	특정 문자열을 다른 문자열로 대체합니다.
string.Empty	빈문자열를 표시하기 위해 매번 2중쌍따옴표(")를 사용하는 대신 공백을 표현하는데 사용될 수 있습니다.
string.Concat	두 문자열 변수를 연결합니다. +연산자를 피연산자인 문자열 사이에 사용해도 동일한 결과를 얻을 수 있습니다.
string.Join	하나 또는 그 이상의 문자열을 각각의 문자열 변수 사이에 문자를 통해 연결합니다.
string.IsNullOrEmpty	string변수가 null이거나 비어있는지를 확인합니다.
string.IsNullOrWhitespace	string변수가 null이거나 공백인지를 확인합니다. 이때 공백은 tab, space, carriage return, line feed등을 포함합니다.
string.Format	형식화된 문자열변수를 출력하기 위한 보간문자열의 대체 method로 명명된 매개변수대신 위치를 사용합니다.

상기 method 중 'string.'으로 표시된 method는 static method입니다. 즉, instance변수가 아닌 type에서부터 바로 호출될 수 있습니다.

Program.cs에서 문자열값의 배열을 가져와 Join method를 통해 분리 문자열을 사용하여 단일 문자열로 결하는 문을 추가합니다.

string cities = "Seoul,Busan,Daegu,Daejeon,Jeju";
string[] citiesArray = cities.Split(',');
string recombined = string.Join(" => ", citiesArray);

Console.WriteLine(recombined);

예제를 실행하면 다음과 같은 결과를 확인할 수 있습니다.

그리고 위치 매개변수와 보간 문자열 서식 구문을 사용해 같은 세 개의 변수를 두 번 표시하도록 하는 문을 추가합니다.

string fruit = "Apples";
int price = 2000;

DateTime when = DateTime.Today;

Console.WriteLine($"Interpolated: {fruit} cost {price:C} on {when:dddd}.");
Console.WriteLine(string.Format("string.Format: {0} cost {1:C} on {2:dddd}.", arg0: fruit, arg1: price, arg2: when));

예제를 실행하면 다음과 같은 결과를 표시합니다.

JetBrains Rider와 같은 일부 편집기에서는 boxing연산에 대한 경고문구를 표시할 수 있으나 지금 상황에서는 무시해도 딥니다. 만약 이러한 경고문구를 보지 않게 하고자 한다면 price와 when에서 ToString() method를 호출하면 됩니다.

참고로 Console.WriteLine method는 string.Format와 동일한 서식을 지원하고 있기 때문에 좀 더 문을 간소화할 수 있습니다.

Console.WriteLine("WriteLine: {0} cost {1:C} on {2:dddd}.", arg0: fruit, arg1: price, arg2: when);

(8) 문자열을 효휼적으로 다루기

String.Concat method나 혹은 간단히 + 연산자를 사용하면 2개의 문자열을 결합해 새로운 문자열을 만들 수 있습니다. 하지만 이런 식의 문자열결합은 .NET이 memory에 완전히 새로운 문자열을 생성해야 하므로 좋지 않은 방법이라 할 수 있습니다.

물론 대게는 단순히 2개의 문자열을 결합하는 경우라면 큰 문제가 없을 테지만 반복문안에서 많은 수의 반복으로 문자열결합을 구현하는 경우라면 성능면에서 부정적인 영향을 줄 수 있으며 memory낭비 역시 초래할 수 있습니다.

따라서 다수의 문자열을 많이 결합해야 하는 경우라면 StringBuilder type을 사용하는 것이 좋습니다. 이에 관한 내용은 아래 link을 참고해 주시기 바랍니다.

StringBuilder Class (System.Text) | Microsoft Learn

StringBuilder Class (System.Text)

Represents a mutable string of characters. This class cannot be inherited.

learn.microsoft.com

3. 정규 표현식을 통한 pattern matching

흔히 정규 표현식은 사용자로부터의 입력을 검증하는 데 사용되곤 합니다. 정규표현식은 아주 강력하지만 동시에 매우 복잡해질 수 있습니다. 거의 모든 programming언어가 정규표현식을 지원하고 있으며 이를 정의하기 위해 공통적인 특별한 문자들을 사용합니다.

표현식의 예를 만들어 보기 위해 csStudy08 solution에서 WorkingWithRegularExpressions이름의 Console App project를 생성합니다.

(1) 문자열로서 입력된 숫자 확인하기

숫자 입력을 검증하는 일반적인 예를 구현하는 것으로 시작해 보고자 합니다.

WorkingWithRegularExpressions project의 Program.cs에서 사용자에게 나이입력을 요청하고 입력된 값에서 숫자문자를 찾는 정규표현식을 아래와 같이 작성합니다.

using System.Text.RegularExpressions;

Console.Write("Enter your age: ");

string input = Console.ReadLine()!;

Regex ageChecker = new(@"\d");

if (ageChecker.IsMatch(input))
{
	Console.WriteLine("Thank you!");
}
else
{
	Console.WriteLine($"This is not a valid age: {input}");
}

위 예제에서는 아래 사항에 주목해야 합니다.

@문자는 문자열 안에서 escape문자를 사용할 수 있는 기능을 끄는데, escape문자 앞에는 backslash가 붙습니다. 예를 들어 \t는 tab을 의미하며 \n은 new line을 의미합니다. 표현식을 사용할 때는 이 기능을 바꿔 사용해야 하므로 disable 해야 합니다.
Escape문자가 @문자를 통해 비활성화되면 정규표현식으로 해석될 수 있습니다. 예를 들어 \d는 숫자를 의미하게 되는 것입니다. 이 부분에 관해서는 잠시 후 더 자세히 알아볼 것입니다.

예제를 실행하면 나이를 묻게 되고 숫자를 입력하면 다음과 같은 결과가 표시될 것입니다.

그런데 숫자가 아닌 다른 형태로 값을 입력하게 되면 결과는 달라지게 됩니다.

이번에는 숫자와 다른 문자를 섞어 입력해 봅니다.

정규표현식에서는 \d를 사용했습니다. 이는 숫자 하나를 의미합니다. 그러나 한자리 숫자 앞뒤에 무엇이 입력될 수 있는지는 명시하지 않았습니다. 해당 정규표현식을 풀어서 설명하면 '하나의 숫자를 입력하는 한 어떤 문자를 입력해도 상관없다.'가 됩니다.

정규표현식에서는 ^문자를 통해 시작되어야 하는 값을 나타낼 수 있고 $문자를 통해서는 끝나냐 하는 값을 나타낼 수 있습니다. 예제에서는 이들 기호문자를 사용해 숫자를 제외하고 입력된 값 앞뒤에 아무것도 없음을 아래와 같이 표시하도록 합니다.

Regex ageChecker = new(@"^\d+$");

이제 예제를 다시 실행하면 어떤 길이든지 0과 정수만 허용하게 됨을 알 수 있습니다.

(2) 정규 표현식 성능 향상

정규표현식 사용을 위한 .NET type은 .NET platform전역에서 사용될 수 있으며 다수의 app이 이를 내장하고 있습니다. 따라서 이들은 성능에 중요한 영향력을 가지고 있지만 Microsoft로 부터의 최적화에 대한 관심을 받지 못했습니다.

.NET 5 이후에 들어와서는 System.Text.RegularExpressions namespace가 최대의 성능을 이끌어 내기 위해 내부적으로 재작성되으며 IsMatch와 같은 method를 사용한 일반적인 정규표현식 benchmark에서는 5배 정도 빠르게 측정되었습니다. 게다가 이러한 성능적 혜택을 누리기 위해 기존에 작성되었던 code를 다시 바꿀 필요가 없습니다.

.NET 7에서 Regex class의 IsMatch method는 성능향상을 위한 ReadOnlySpan<char>을 전달할 수 있는 overload를 갖고 있습니다.

(3) 정규 표현식 문법

아래 표는 정규표현식에서 사용할 수 있는 일반적인 기호문자를 정리한 것입니다.

기호	의미	기호	의미
^	시작값	$	끝값
\d	숫자	\D	비숫자
\s	공백	\S	비공백
\W	단어 문자	\W	비단어 문자
[A-Za-z0-9]	문자의 범위	\^	^(caret) 문자
[aeiou]	가능한 문자집합	[^aeiou]	비가능한 문자집합
.	모든 단일문자	\.	.(dot) 문자

추가적으로 아래는 정규표현식에서 이전 기호에 영향을 주는 일부 정규표현식 한정자를 정리한 것입니다.

기호	의미	기호	의미
+	하나 또는 그 이상	?	하나 아니면 없음
{3}	정확히 3개	{3,5}	3~5
{3,}	최소3개	{,3}	3이상

(4) 정규 표현식 예제

아래 표에서는 정규식을 통한 몇 가지 예를 나타내고 있습니다.

표현식	의미
\d	한자리 숫자
a	문자 a
cliel	단어 cliel
^cliel	cliel로 시작하는 단어
cliel$	cliel로 끝나는 단어
^\d{2}$	정확히 2자리 숫자
^[0-9]{2}$	위와 동일, 정확히 2자리 숫자
^[A-Z]{4,}$	ASCII 문자 set에서의 최소 4개의 영문 대문자
^[A-Za-z]{4,}$	ASCII 문자 set에서의 최소 4개의 영문 대소문자
^[A-Z]{2}\d{3}$	ASCII 문자 set에서의 2개 대문자와 3개의 숫자
^[A-Za-z\u00c0-\ u017e]+$	ASCII 문자 set에서의 최소 1개의 대소문자 혹은 Unicode 문자 set에서의 European 문자
^d.g$	문자 d로 시작, 모든 문자, g로 끝나는 경우이므로 dig, dog처럼 d와 g사이에 단일문자
^d\.g$	문자 d로 시작, ., g로 끝나는 경우이므로 d.g에서만 일치

정규표현식은 거의 공통이므로 한번 사용한 정규표현식은 JavaScript나 Python과 같은 다른 언어에서 재사용이 가능합니다.

(5) 쉼표(,)로 구분된 문자열의 분리

위의 '문자열 분리'에서는 comma(,)로 구분된 문자열 변수에서 문자열을 어떻게 분리할 수 있을지에 대한 예제를 만들어본 바 있습니다. 그런데 아래와 같은 경우는 위에서 처럼 단순하게 처리할 수는 없는 형태입니다.

"aaa,bbb","ccc,ddd","eee,fff"

위 문자열값은 각각에서 큰따옴표(")를 사용하고 있으며 해당 값들은 쉼표(,)로 분리할 필요가 있는지 여부를 확인하기 위해 사용할 것입니다. 문자열 분리를 위한 Split method가 존재하지만 해당 예제에서는 맞지 않으므로 정규표현식을 대신 사용해야 합니다.

아래 link는 해당 예제를 작성하는데 영향을 받게 된 Stack Overflow의 article로서 더 자세한 설명을 확인해 볼 수 있습니다.

string문자열 안에서 큰따옴표(")를 포함시키기 위해 이들 앞에 backslash를 붙여주거나 C# 11부터 도입된 'raw string literal'을 사용할 수 있습니다.

Program.cs에서 comma로 구분된 문자열값을 저장하는 변수를 추가하고 Split method를 통해 문자열을 나누어 봅니다.

string str = """
"aaa,bbb","ccc,ddd","eee,fff"
""";

Console.WriteLine($"Strings to split: {str}");

string[] attrStr = str.Split(',');

Console.WriteLine("Splitting with string.Split method:");
foreach (string s in attrStr)
{
	Console.WriteLine(s);
}

그다음 해당 문자열을 다시 정규표현식을 통해 나누는 문을 아래와 같이 작성합니다.

Regex csv = new("(?:^|,)(?=[^\"]|(\")?)\"?((?(1)[^\"]*|[^,\"]*))\"?(?=,|$)");
MatchCollection colStr = csv.Matches(str);

Console.WriteLine("Splitting with regular expression:");
foreach (Match s in colStr)
{
	Console.WriteLine(s.Groups[2].Value);
}

예제를 실행하면 다음과 같은 결과를 볼 수 있을 것입니다.

(6) 정규표현식 구문강조 사용하기

Visual Studio 2022를 사용한다면 위에서 정규표현식을 사용하고자 생성자값으로 문자열을 전달할 때 색상으로 구문이 강조되어 있음을 확인할 수 있습니다.

일반적인 문자열값을 처리할 때 적용되지 않던 색상 구문 강조가 정규 표현식을 사용할 때 적용된 이유는 무엇일까?

그 이유를 알아보기 위해 생성자에서 mouse오른쪽 button을 click 한 뒤 'Go To Implementation'항목을 선택합니다. 그러면 pattern 문자열 매개변수에 Regex 상수값이 전달된 StringSyntax 이름의 attribute가 적용되어 있음을 알 수 있습니다.

/// <summary>
/// Creates a regular expression object for the specified regular expression.
/// </summary>
public Regex([StringSyntax(StringSyntaxAttribute.Regex)] string pattern) :
this(pattern, culture: null)
{
}

여기서 다시 StringSyntax attribute에 mouse오른쪽 click한뒤 'Go To Implementation'항목을 선택합니다. 결과를 보면 Regex를 포함해 선택가능한 12개의 인식된 문자열 구문형식이 존재함을 알 수 있습니다.

public const string CompositeFormat = nameof(CompositeFormat);

/// <summary>The syntax identifier for strings containing date format specifiers.</summary>
public const string DateOnlyFormat = nameof(DateOnlyFormat);

/// <summary>The syntax identifier for strings containing date and time format specifiers.</summary>
public const string DateTimeFormat = nameof(DateTimeFormat);

/// <summary>The syntax identifier for strings containing <see cref="Enum"/> format specifiers.</summary>
public const string EnumFormat = nameof(EnumFormat);

/// <summary>The syntax identifier for strings containing <see cref="Guid"/> format specifiers.</summary>
public const string GuidFormat = nameof(GuidFormat);

/// <summary>The syntax identifier for strings containing JavaScript Object Notation (JSON).</summary>
public const string Json = nameof(Json);

/// <summary>The syntax identifier for strings containing numeric format specifiers.</summary>
public const string NumericFormat = nameof(NumericFormat);

/// <summary>The syntax identifier for strings containing regular expressions.</summary>
public const string Regex = nameof(Regex);

/// <summary>The syntax identifier for strings containing time format specifiers.</summary>
public const string TimeOnlyFormat = nameof(TimeOnlyFormat);

/// <summary>The syntax identifier for strings containing <see cref="TimeSpan"/> format specifiers.</summary>
public const string TimeSpanFormat = nameof(TimeSpanFormat);

/// <summary>The syntax identifier for strings containing URIs.</summary>
public const string Uri = nameof(Uri);

/// <summary>The syntax identifier for strings containing XML.</summary>
public const string Xml = nameof(Xml);

WorkingWithRegularExpressions project에서 Strings. cs라는 이름의 class file을 추가한 뒤 2개의 문자열 상수를 정의하는 문을 작성합니다.

partial class Program
{
	const string digitsOnlyText = @"^\d+$";
	const string commaSeparatorText = "(?:^|,)(?=[^\"]|(\")?)\"?((?(1)[^\"]*|[^,\"]*))\"?(?=,|$)";
}

Visual Studio 2022에서 위 예제를 작성하면 아직까지는 정규식에 색상 구문 강조가 적용되지 않습니다.

Program.cs에서 literal string을 아래와 같이 digits-only 정규 표현식에 대한 string constant로 바꾸고

Regex ageChecker = new(digitsOnlyText);

WorkingWithText project의 comma 분리 정규표현식에서도 아래와 같이 string constant로 바꾸어 줍니다.

Regex csv = new(commaSeparatorText);

Strings.cs에서는 StringSyntax attribute를 위한 namespace를 추가하고 string상수 둘다에 StringSyntax attribute를 적용합니다.

partial class Program
{
	[StringSyntax(StringSyntaxAttribute.Regex)]
	const string digitsOnlyText = @"^\d+$";

	[StringSyntax(StringSyntaxAttribute.Regex)]
	const string commaSeparatorText = "(?:^|,)(?=[^\"]|(\")?)\"?((?(1)[^\"]*|[^,\"]*))\"?(?=,|$)";
}

이어서 날짜의 서식화를 위한 또 다른 상수를 아래와 같이 추가하고

[StringSyntax(StringSyntaxAttribute.DateTimeFormat)]
const string fullDateTime = "";

fullDateTime문자열 안에 'd'를 typing 하면 IntelliSense가 작동됨을 알 수 있습니다.

fullDateTime변수에 'yyyy-MM-dd'형식의 날짜 format을 지정하고 digitsOnlyText의 끝에는 \문자를 추가합니다. 이때 IntelliSense를 통해 올바른 정규표현식을 입력하는데 도움을 받을 수 있습니다.

[StringSyntax] attribute는 .NET 7에서 새롭게 도입된 기능으로 이를 인식하는 것은 code editor의 몫입니다. .NET 7에는 이뿐만 아니라 해당 attribute에 적용할 수 있는 350개 이상의 매개변수, 속성, field를 갖고 있습니다.

(7) Source generator를 통한 정규표현식의 성능향상

문자열값 혹은 문자열상수를 Regex의 생성자로 전달하면 class는 문자열을 분석하여 정규표현식 번역기에 의해 효휼적으로 실행될 수 있도록 최적화된 방식으로 표현식을 나타내는 내부 tree구조로 변환합니다.

정규 표현식은 RegexOption을 지정함으로써 아래와 같이 compile 할 수 있습니다.

Regex ageChecker = new(digitsOnlyText, RegexOptions.Compiled);

그런데 compiling은 정규표현식의 초기생성 속도를 늦추는 부정적인 효과를 가지고 있습니다. 번역기가 실행할 tree구조가 생성되고 나면 compiler는 이 tree를 IL code로 변환하고 IL code를 native code로 JIT compile 해야 합니다. 정규표현식을 몇 번만 실행시킬 거라면 이것을 굳이 compile 할 필요가 없을 것입니다.

.NET 7에서는 [GeneratedRegex] attribute를 Regex를 반환하는 partial method에 적용하면 이를 인식하는 정규표현식에 대한 source generator를 도입하였는데 이는 정규표현식에 대한 logic을 구현하는 method의 구현을 생성합니다.

WorkingWithRegularExpressions project에서 Regexs.cs라는 새로운 class file을 생성하고 아래와 같이 partial method를 정의합니다.

partial class Program
{
    [GeneratedRegex(digitsOnlyText, RegexOptions.IgnoreCase)]
    private static partial Regex DigitsOnly();
    [GeneratedRegex(commaSeparatorText, RegexOptions.IgnoreCase)]
    private static partial Regex CommaSeparator();
}

그리고 Program.cs에서 아래와 같이 digits-only 정규표현식을 반환하는 partial method를 호출하도록 생성자를 바꿔주고

Regex ageChecker = DigitsOnly();

comma 구분자 정규 표현식을 반환하는 partial method를 호출하도록 하는 생성자도 아래와 같이 바꿔줍니다.

Regex csv = CommaSeparator();

여기에서 각 partial method에 mouse pointer를 올려보면 표현식에 대한 동작을 설명하는 tooltip을 볼 수 있습니다.

그리고 DigitsOnly partial method를 mouse 오른쪽 click 하여 'Go To Definition'을 click 해 보면 자동으로 생성된 partial method의 구현체를 확인해 볼 수 있습니다.

예제를 실행하고 기존의 동작과 같은지를 확인합니다.

아래 link에서는 .NET 7에서 정규 표현식의 구현에 대한 더 많은 내용을 확인할 수 있습니다.

Regular Expression Improvements in .NET 7 - .NET Blog (microsoft.com)

Regular Expression Improvements in .NET 7 - .NET Blog

System.Text.RegularExpressions has improved significantly in .NET 7. In this post, we'll deep-dive into many of its exciting improvements.

devblogs.microsoft.com

4. Collection에서 다중 개체 저장하기

Data와 관련된 또 다른 가장 일반적인 type으로는 collection을 들 수 있습니다. Collection은 다중값을 저장하는 일반적인 type입니다.

Collection은 memory에 있는 data구조로서 모든 collection이 일부 기능을 공유하고 있기는 하지만 나름대로의 방식으로 다중 item을 관리할 수 있습니다.

아래 표는 .NET에서 collection을 사용하기 위한 가장 일반적인 type을 나타낸 것입니다.

Namespace	Example type(s)	Description
System.Collections	IEnumerable, IEnumerable<T>	Collection에서 사용되는 Interface와 기반 class
System.Collections.Generic	List<T>, Dectionary<T>, Queue<T>, Stack<T>	.NET Framework 2.0과 함께 C# 2.0에서 도입된 것으로 generic type 매개변수를 통해 원하는 type을 지정할 수 있는 collection (더 안전하고, 더 빠르며, 더 효휼적인)
System.Collections.Concurrent	BlockingCollection, ConcurrentDictionary, ConcurrentQueue	Multithread scenario에서 사용하기에 안전한 collection
System.Collections.Immutable	ImmutableArray, ImmutableDictionary, ImmutableList, ImmutableQueue	본래 collection의 content가 절대 바뀌지 않는다는 scenario를 위해 설계된 것으로 다만 새로운 instance를 생성함으로서 기존의 collection을 변경할 수 있음

(1) 모든 collection에서의 공통기능

모든 collection은 ICollection interface를 구현하고 있고 때문에 얼마나 많은 개체가 존재하는지를 의미하는 Count속성을 가지고 있습니다.

public interface ICollection : IEnumerable
{
	int Count { get; }
	bool IsSynchronized { get; }
	object SyncRoot { get; }
	void CopyTo(Array array, int index);
}

예를 들어 한 학급의 학생에 대한 collection이 존재한다면 다음과 같이 학생의 수를 구할 수 있습니다.

int howMany = students.Count;

또한 모든 collection은 IEnumerable interface를 구현합니다. 때문에 foreach문을 통해 각 요소를 열거할 수 있습니다. 그리고 이를 위해서는 IEnumerator를 구현하는 개체를 반환하는 GetEnumerator method를 가져야 하며 반환된 개체는 collection을 탐색할 수 있는 MoveNext와 Reset method 그리고 collection에서 현재 item을 가지고 있는 Current 속성을 가져야 합니다.

public interface IEnumerable
{
	IEnumerator GetEnumerator();
}

public interface IEnumerator
{
	object Current { get; }
	bool MoveNext();
	void Reset();
}

이렇게 되면 students collection에서 각 개체에 대해 아래와 같은 동작을 수행할 수 있습니다.

foreach (Student s in students)
{

}

개체 기반 collection interface뿐만 아니라 collection에 저장되는 type을 정의하는 generic type generic interface와 class도 존재합니다.

public interface ICollection<T> : IEnumerable<T>, IEnumerable
{
    int Count { get; }
    bool IsReadOnly { get; }
    void Add(T item);
    void Clear();
    bool Contains(T item);
    void CopyTo(T[] array, int index);
    bool Remove(T item);
}

(2) Collection의 가용성을 지정하여 성능 향상하기

.NET 1.1부터 StringBuilder와 같은 type은 EnsureCapacity라는 이름의 method를 가지고 있어서 이를 통해 array를 저장하는 size를 미리 지정할 수 있었고 따라서 string의 마지막 size를 예상할 수 있었습니다. 이 것은 문자가 추가됨으로서 array의 size를 반복적으로 증가시키지 않아도 되므로 성능에 도움이 될 수 있습니다.

.NET 6부터 List<T>, Queue<T>, Stack<T>와 같은 collection은 같은 역할로 EnsureCapacity이름의 method를 가지게 되었으며 아래와 같이 사전 size를 지정할 수 있게 되었습니다.

List<string> names = new();
names.EnsureCapacity(10000);

(3) Collection의 종류

Collection은 사용하고자 하는 목적에 따라 lists, dictionaries, queues, sets 등 선택가능한 여러 가지가 존재합니다.

● Lists

IList<T>를 구현하는 List는 정렬된 collection입니다.

[DefaultMember("Item")]
public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
{
    T this[int index] { get; set; }
    int IndexOf(T item);
    void Insert(int index, T item);
    void RemoveAt(int index);
}

DefaultMember attribute는 member의 이름이 지정되지 않았을 경우 기본적으로 접근될 member를 지정합니다. 따라서 만약 IndexOf를 기본 member로 지정하고자 한다면 [DefaultMember("IndexOf")]와 같이 사용할 수 있습니다. 예제에서 Item은 Indexer를 의미합니다.

IList<T>는 ICollection<T>로 부터 파생되므로 Count속성을 가지고 있으며 collection끝에 item을 추가하기 위한 Add method와 특정한 위치에 item을 추가하는 Insert method, 지정한 위치에 item을 제거하는 RemoveAt method를 가지고 있습니다.

따라서 List는 수동적으로 collection의 item 순서를 조정할 수 있습니다. List의 각 item은 자동적으로 할당된 고유한 index(또는 위치값)를 가지고 있으며 또한 T에 의해 어떠한 type으로도 item이 정의될 수 있고 필요하다면 중복으로 item을 저장시킬 수 있습니다. Index는 int type으로서 0부터 시작하므로 list의 첫 번째 item의 index값은 0이 됩니다.

Index	Item
0	apple
1	banana
2	orange

만약 위 상태에서 banana와 orange사이에 lemon이라는 새로운 item이 삽입되면 orange의 index는 자동적으로 증가됩니다. 따라서 item의 index는 다른 item의 삽입이나 제거로 인해 바뀔 수 있음에 주의해야 합니다.

Index	Item
0	apple
1	banana
2	lemon
3	orange

때로는 Array가 더 나은 상황임에도 굳이 List<T>나 다른 collection을 사용하는 경우가 있습니다. 그러나 이는 좋지 않은 습관입니다. Data의 size가 instance화 된 이후에 바뀌는 않는 경우라면 array를 사용하는 것이 좋습니다. 먕갸 data의 조작이 필요한 경우라면 처음에는 list를 사용하여 필요한 변경을 수행하고 그 다음 array로 변환하여 사용합니다.

● Dictionary

Dictionary는 각 값(또는 개체)이 고유한 하위 값을 가질 수 있으며 이는 collection에서 빠르게 값을 찾는 key로 사용될 수 있습니다. 여기서 key는 고유해야 합니다. 예를 들어 사람에 대한 list를 저장하는 경우라면 주민등록번호를 key로서 사용할 수 있을 것입니다. Dictionary는 Python과 Java와 같은 다른 언어에서는 hashmaps라고도 합니다.

Key는 실제 사전에서 index항목과 같이 생각할 수 있습니다. 단어(즉, key)는 정렬된 상태로 유지되므로 빠르게 단어의 정의를 찾을 수 있게 하며 만약 manatee단어에 대한 정의를 찾는다고 하면 사전의 중간쯤부터 시작할 수 있을 것입니다. 왜냐하면 문자 M은 alphabet의 중간쯤에 위치해 있기 때문입니다.

Programming에서 Dictionary는 무엇인가를 찾을 때 위와 비슷하게 동작할 수 있습니다. Dictionary는 IDictionary<TKey, TValue> interface를 구현합니다.

[DefaultMember("Item")] // aka this indexer
public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
{
    TValue this[TKey key] { get; set; }
    ICollection<TKey> Keys { get; }
    ICollection<TValue> Values { get; }
    void Add(TKey key, TValue value);
    bool ContainsKey(TKey key);
    bool Remove(TKey key);
    bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value);
}

Dictionary의 item은 값 type인 KeyValuePair<TKey, TValue> struct의 instance로서 TKey는 key의 type이며 TValue는 value의 type입니다.

public readonly struct KeyValuePair<TKey, TValue>
{
    public KeyValuePair(TKey key, TValue value);
    public TKey Key { get; }
    public TValue Value { get; }
    
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void Deconstruct(out TKey key, out TValue value);
    public override string ToString();
}

예를 들어 Dictionary<string, Person>는 key로서 string을, 값(value)으로서 Person instance를 사용하는 것입니다. 아래 예제 Dictionary<string, string>은 값과 key로서 둘 다 string을 사용합니다.

key	value
801201-1	홍길동
750405-2	홍길남
820712-1	홍길석

● Stack

Stack는 LIFO(last-in, first-out) 동작을 구현하기에 적합합니다. 따라서 stack에서는 전체 item을 열거할 수는 있지만 stack의 가장 상위에 있는 하나의 item에 대한 직접적인 접근 및 제거만이 가능합니다. Stack에 대한 두 번째나 세 번째 등의 접근 불가능합니다.

Stack의 가장 대표적인 사례로는 word process를 들 수 있습니다. Stack을 통해 우리가 한 동작을 순서대로 기억하고 있다가 Ctrl + Z key를 누르게 되면 stack에서 마지막 동작을 읽어 되돌리게 되는 것입니다.

● Queue

Queue는 FIFO(first-in, first-out)동작을 구현하기에 적합합니다. 따라서 queue에서는 전체 item을 열거할 수는 있지만 queue의 가장 앞에 있는 item에 대한 직접적인 접근및 제거만이 가능하며 두번째나 세번째등의 접근은 불가능합니다.

Queue의 가장 대표적인 사례로는 은행에서 줄을 서 있는 사람들처럼 들어온 순서대로 작업 item을 처리할 때 queue를 사용한 경우를 들 수 있습니다.

.NET 6에서는 queue의 각 item에 position과 우선순위값이 할당된 PriorityQueue를 도입하였습니다.

Program.cs에 queue를 정의하고 사용하는 일반적인 방법을 나타내는 문을 아래와 같이 추가합니다. 예제는 Queue를 통해 음식점에서 손님에게 순서대로 주문한 음식을 제공하는 경우를 나타낸 것입니다.

Queue<string> foods = new();
foods.Enqueue("제육볶음");
foods.Enqueue("된장찌개");
foods.Enqueue("김치찌개");
foods.Enqueue("백반정식");
foods.Enqueue("라면");

Output("Initial queue from front to back", foods);

string served = foods.Dequeue();
Console.WriteLine($"Served: {served}.");

served = foods.Dequeue();
Console.WriteLine($"Served: {served}.");
Output("Current queue from front to back", foods);

Console.WriteLine($"{foods.Peek()} is next in line.");
Output("Current queue from front to back", foods);

예제를 실행하면 다음과 같은 결과를 볼 수 있습니다.

Helpers.cs의 partial Program class에서 OutputPQ라는 이름의 정적 method를 아래와 같이 추가합니다.

static void OutputPQ<TElement, TPriority>(string title, IEnumerable<(TElement Element, TPriority Priority)> collection)
{
    Console.WriteLine(title);

    foreach ((TElement, TPriority) item in collection)
    {
        Console.WriteLine($" {item.Item1}: {item.Item2}");
    }
}

OutputPQ는 generic임에 주목합니다. 이를 통해 collection에 전달되는 tuple에서 사용할 2개의 type을 지정할 수 있습니다.

Program.cs에서는 priority queue를 정의하고 사용하는 일반적인 방법을 나타내는 문을 아래와 같이 추가합니다.

PriorityQueue<string, int> foods = new();
foods.Enqueue("제육볶음", 1);
foods.Enqueue("된장찌개", 4);
foods.Enqueue("김치찌개", 3);
foods.Enqueue("백반정식", 2);
foods.Enqueue("라면", 1);

OutputPQ("Initial queue from front to back", foods.UnorderedItems);
Console.WriteLine($"{foods.Dequeue()} has been served.");
Console.WriteLine($"{foods.Dequeue()} has been served.");

OutputPQ("Current queue :", foods.UnorderedItems);
Console.WriteLine($"{foods.Dequeue()} has been served.");
            
Console.WriteLine("Adding Mark to queue with priority 2");
foods.Enqueue("오무라이스", 2);

Console.WriteLine($"{foods.Peek()} will be next to be served.");
OutputPQ("Current queue :", foods.UnorderedItems);

예제에서 Enqueue method의 두 번째 숫자가 우선순위에 해당합니다. 1이 가장 높은 우선순위를 4가 가장 낮은 우선순위가 됩니다.

예제를 실행하면 다음과 같은 결과를 확인할 수 있습니다.

● Set

Set은 2개의 collection사이에 집합 연산을 수행합니다. 예를 들어 과일에 대한 2개의 collection을 가지고 있을 때 2개 collection모두에서 공통적으로 속해있는(집합 사이에 교차하는) 과일의 이름을 알고 싶은 경우 set을 사용할 수 있습니다. Set에서 item은 고유해야 합니다.

일반적으로 사용되는 Set method는 아래와 같습니다.

Add	Item이 존재하지 않는다면 새롭게 추가합니다. Method의 수행결과로 true라면 Item이 추가된 것이고 false라면 해당 Item이 이미 존재하는 경우입니다.
ExceptWith	매개변수로 전달된 set의 item을 set에서 제거합니다.
IntersectWith	매개변수로 전달된 set이 아닌 item을 set에서 제거합니다.
IsProperSubsetOf IsProperSupersetOf IsSubsetOf IsSupersetOf	Subset은 item이 모두 다른 set에 존재하는 set입니다. 적절한 subset은 item이 모두 다른 set에 존재하는 set이지만 다른 set에 없는 item이 최소 하나이상 있는 set입니다. Superset은 모든 item이 다른 set에 있는 set이고 적절한 superset은 다른 set의 모든 item과 다른 set에 존재하지 않는 하나이상의 item을 포함합니다.
Overlaps	Set와 다른 set는 하나 이상의 공통 item을 공유합니다.
SetEquals	Set와 다른 set는 정확히 같은 item을 공유합니다.
SymmetricExceptWith	매개변수로 전달된 set에 속하지 않은 item을 set에서 제거하고 누락된것을 추가합니다.
UnionWith	매개변수로 전달된 set에 아직 set에 없는 item을 추가합니다.

Set에 대한 일반적인 예제를 작성해 보기 위해 Program.cs를 아래와 같이 변경합니다.

HashSet<String> fruits = new();

foreach(string fruit in new[] { "apple", "banana", "orange", "banana" })
{
    bool result = fruits.Add(fruit);

    Console.WriteLine($"result : {result}, {fruit}");
}

예제를 실행하면 다음과 같은 결과를 표시할 것입니다.

● Collection method

각 collection은 item을 추가하거나 삭제할 때 사용하는 일련의 method가 다르며 아래 표는 collection별로 이러한 method를 정리한 것입니다.

Collection	Add method	Remove method	Description
List	Add, Insert	Remove, RemoveAt	List는 정렬되어 있으므로 item은 int형식의 index position을 갖고 있습니다. Add는 list의 끝에 새로운 item을 추가하며 Insert는 지정한 위치에 새로운 item을 추가하게 됩니다.
Dictionary	Add	Remove	Dictionary는 정렬되어 있지 않으므로 item또한 index position을 갖고 있지 않습니다. ContainsKey method를 호출하면 해당 key가 사용되었는지 여부를 확인할 수 있습니다.
Stack	Push	Pop	Push method는 새로운 item을 stack의 상위에 추가합니다. 따라서 첫번째 item은 맨 마지막에 있게 됩니다. Item이 Pop을 통해 제거될때는 stack의 가장 상위의 것이 제거됩니다. Peek method를 호출하면 해당 값을 삭제하지 않고도 확인할 수 있습니다.
Queue	Enqueue	Dequeue	Enqueue method를 통해 item이 추가될때는 항상 queue의 끝에 추가됩니다. 따라서 첫번째 item은 queue의 앞에 있게 됩니다. Dequeue method를 통해 item이 제거될때는 queue의 가장 앞에 있는 item을 제거합니다. Peek method를 호출하면 해당 값을 삭제하지 않고도 확인할 수 있습니다.

(4) List 사용하기

csStudy08 solution에서 WorkingWithCollections이름의 Console App project를 추가하고 Helpers.cs class를 아래와 같이 추가합니다.

partial class Program
{
    static void Output(string title, IEnumerable<string> collection)
    {
        Console.WriteLine(title);

        foreach (string item in collection)
        {
            Console.WriteLine($" {item}");
        }
    }
}

Program.cs에서는 기존의 문을 모두 삭제하고 list를 정의하고 사용하는 일반적인 방법을 나타내는 문을 아래와 같이 추가합니다.

List<string> cities = new();
cities.Add("Daegu");
cities.Add("Seoul");
cities.Add("Busan");

Output("Initial list", cities);
Console.WriteLine($"The first city is {cities[0]}.");
Console.WriteLine($"The last city is {cities[cities.Count - 1]}.");
            
cities.Insert(0, "Jeju");
Output("After inserting Sydney at index 0", cities);

cities.RemoveAt(1);
cities.Remove("Seoul");
Output("After removing two cities", cities);

예제에서 cities list는 아래 2가지 다른 방식으로도 정의될 수 있습니다.

List<string> cities = new() { "London", "Paris", "Milan" };

List<string> cities = new();
cities.AddRange(new[] { "London", "Paris", "Milan" });

예제를 실행하면 다음과 같은 결과가 표시될 것입니다.

(5) Dictionary 사용하기

Program.cs에서는 Dictionary를 정의하고 사용하며 단어를 찾는 등의 일반적인 방법을 나타내는 문을 아래와 같이 추가합니다.

Dictionary<string, string> keywords = new();

keywords.Add(key: "int", value: "32-bit integer data type");
keywords.Add("long", "64-bit integer data type");
keywords.Add("float", "Single precision floating point number");

Output("Dictionary keys:", keywords.Keys);
Output("Dictionary values:", keywords.Values);

Console.WriteLine("Keywords and their definitions");
foreach (KeyValuePair<string, string> item in keywords)
{
    Console.WriteLine($" {item.Key}: {item.Value}");
}

string key = "long";
Console.WriteLine($"The definition of {key} is {keywords[key]}");

예제에서 첫 번째 Add method는 명명된 매개변수를 사용한 추가방식을 나타내고 있습니다. 또한 Dictionary는 아래와 같은 2가지 다른 방식을 통해 정의될 수 있습니다.

Dictionary<string, string> keywords = new()
{
    { "int", "32-bit integer data type" },
    { "long", "64-bit integer data type" },
    { "float", "Single precision floating point number" },
};

Dictionary<string, string> keywords = new()
{
    ["int"] = "32-bit integer data type",
    ["long"] = "64-bit integer data type",
    ["float"] = "Single precision floating point number",
};

특히 상기예제에서 마지막 comma(,)는 생략할 수 있습니다.

(6) Collection 정렬

List<T> class에서는 Sort method를 호출함으로써 수동적으로 정렬할 수 있습니다(단, 각 item의 index는 바뀔 수 있습니다.). 문자열값 혹은 다른 내장 type의 list를 수동적으로 정렬하는 것은 별도의 구현이 필요 없이 작업이 가능하지만 자신만의 type으로 collection을 생성한 경우라면 해당 type은 IComparable이름의 interface를 구현해야 합니다. 이에 대한 자세한 내용은 아래 글에서 확인하실 수 있습니다.

[.NET/C#] - [C# 12와 .NET 8] 6. Interface와 Class상속

[C# 12와 .NET 8] 6. Interface와 Class상속

lab.cliel.com

Stack<T>또는 Queue<T> collection은 근본적인 특성상 정렬이 불가능하며 Dictionary 혹은 set에서는 정렬이 가능할 수 있습니다.

하지만 때로는 자동적으로 정렬된 collection, 즉, item을 추가하거나 삭제하면 그것대로 순서대로 정렬된 item을 유지하는 것을 사용하는 것이 유용할 때가 있습니다.

이를 위해 선택가능한 여러 자동정렬 collection들이 존재합니다. 이들 정렬된 collection의 차이는 미묘하지만 application에서 사용될 때 필요한 memory와 성능에는 큰 영향이 있을 수 있습니다. 따라서 필요에 따라 가장 적합한 것을 선택할 수 있도록 신중해질 필요가 있습니다.

선택가능한 자동정렬 collection에는 다음과 같은 것들이 있습니다.

Collection	설명
SortedDictionary<TKey, TValue>	key에 의해 정렬된 key/값 쌍의 collection입니다.
SortedList<TKey, TValue>	key에 의해 정렬된 key/값 쌍의 collection입니다. SortedDictionary<TKey, TValue>와 비교하여 열거하는 성능은 비슷하지만 더 적은 memory를 사용하며 정렬되어 있지 않은 상태에서는 insert나 remove동작은 느리지만 정렬되어 있다면 더 빠르게 동작합니다.
SortedSet<T>	순서대로 정렬된 상태를 유지하는 고유한 개체의 collection입니다.

(7) 더 전문화된 collection

위의 collection 외 더 특별한 상황을 위한 다른 collection들이 존재합니다.

● Bit 값을 사용하는 compact array

System.Collections.BitArray collection은 bool형식의 bit값에 대한 array를 관리하며 true라면(값이 1이라면) bit가 on이고 false라면(값이 0이라면) bit가 off임을 의미합니다.

● Efficient list

System.Collections.Generics.LinkedList<T> collection은 이중연결 list를 나타내는 것으로 모든 item은 전의 item과 후의 item에 대한 참조를 갖고 있습니다. 이러한 구조로 list의 중간쯤에 자주 item에 대한 insert나 remove가 이루어지는 상황이라면 List<T>와 비교해 더 우월한 성능을 나타내며 구조의 특성상 LinkedList<T>에서 item은 memory에서 재정렬될 필요가 없습니다.

(8) Read-only , Immutable, frozen collection

Generic collection interface를 보면 IsReadOnly라는 속성이 존재함을 알 수 있습니다. 이 속성은 method에 collection을 전달할때 해당 collection에 어떠한 변경도 허용하지 말아야 할 경우 유용하게 사용할 수 있습니다.

List<T>와 Dictionary<TKey, TValue>와 같은 collection는 AsReadOnly method를 갖고 있는데 이를 통해 본래 collection을 참조하는 ReadOnlyCollection<T>를 생성하게 됩니다. ReadOnlyCollection<T>도 ICollection<T> interface를 구현하고 있기 때문에 Add나 Remove와 같은 method를 갖고 있지만 해당 method의 호출을 시도하면 NotImplementedException을 throw하게 됩니다. ReadOnlyCollection<T>는 참조이므로 본래 collection에서 item의 추가나 삭제와 같은 변경사항이 발생하면 당연히 ReadOnlyCollection<T>에도 그대로 변경사항이 적용됩니다.

Console.OutputEncoding = System.Text.Encoding.UTF8;

void UseDictionary(IDictionary<string, string> dictionary)
{
    try
    {
        dictionary.Add(key: "A7", value: "홍길석"); 
    }
    catch (NotSupportedException)
    {
        Console.WriteLine("collection이 읽기 전용임.(item을 추가할 수 없음).");
    }
    
    Console.WriteLine($"전체 요소 수 : {dictionary.Count}");
}

Dictionary<string, string> employees = new Dictionary<string, string>();
employees.Add("A1", "홍길순");
employees.Add("A2", "홍길동");
employees.Add("A3", "홍길영");

UseDictionary(employees);

위 예제에서는 method에서 dicttionary type을 전달받아 새로운 item을 추가하도록 합니다.

method에서는 IDictionary type의 인수가 정의되어 있습니다. 특정 type보다 interface를 사용하면 program에 더 많은 유연성을 부여할 수 있습니다. 예제에서도 IDictionary interface를 사용해 Dictionary<TKey, TValue>나 ReadOnlyDictionary<TKey, TValue>등 해당 interface를 구현한 모든 type을 잔달받을 수 있습니다.

예제를 실행하면 method안에서 정상적으로 item을 추가하게 되었으므로 Count의 수는 늘어나게 됩니다.

이번에는 AsReadOnly method를 통해 읽기전용 collection을 전달해 봅니다.

UseDictionary(employees.AsReadOnly());

실행결과는 다음과 같습니다.

method에서는 item을 추가할 수 없기 때문에 결과에서의 Count값은 기존과 동일합니다.

Immutable collection은 말 그대로 불변의 collection을 생성합니다. 다시 말해 collection의 member는 바뀔 수 없고 따라서 추가나 삭제도 불가능합니다.

Immutable collection은 System.Collections.Immutable namespace를 import 하게 되면 IEnumerable<T>를 구현하는 모든 collection은 여섯 개의 확장 method가 주어지는데 이를 통해 immutable list나 dictionary, hash, set 등으로 변환하는 것으로 사용할 수 있습니다.

WorkingWithCollections의 Program.cs에서 System.Collections.Immutable namespace를 import 하고 cities list를 immutable list로 변환한 뒤 새로운 item을 아래와 같이 추가하도록 합니다.

List<string> cities = new();
cities.Add("Daegu");
cities.Add("Seoul");
cities.Add("Busan");

ImmutableList<string> immutableCities = cities.ToImmutableList();
ImmutableList<string> newList = immutableCities.Add("Jeju");
Output("Immutable list of cities:", immutableCities);
Output("New list of cities:", newList);

예제를 실행하면 다음과 같은 결과를 볼 수 있습니다.

예제에서 cities의 immutable list는 바뀌지 않음에 주목해야 합니다. Add method를 통해 item을 추가하게 되면 자신을 바꾸는 것이 아닌 기존의 것에서 새로운 것이 추가된 상태의 list가 새롭게 반환됩니다.

성능향상을 위해 많은 application에서는 공통적으로 접근되는 개체의 공유복사본을 cache에 복사하고 여러 thread에서의 안정적인 동작이 필요한 경우 이를 immutable로 만들거나 concurrent collection type을 사용하게 됩니다. 이와 관련해서는 아래 link에서 자세한 내용을 확인할 수 있습니다.

System.Collections.Concurrent Namespace | Microsoft Learn

System.Collections.Concurrent Namespace

Provides several thread-safe collection classes that should be used in place of the corresponding types in the System.Collections and System.Collections.Generic namespaces whenever multiple threads are accessing the collection concurrently. However, access

learn.microsoft.com

Generic collection은 설계된 방식으로 인해 잠재먹인 성능 issue를 갖고 있습니다.

첫번째로는 dictionary에서 key와 값에 사용되는 type이 어떤 것이냐에 따라 성능에 큰 영향을 준다는 것입니다. 거의 모든 type을 다 받아들일 수 있기 때문에 사실상 성능을 최적화하게에는 무리가 있었던 것입니다. 실세 여기에 사용되는 type은 string과 int가 가장 흔한데 만약 .NET team이 type을 이것으로만 한정하게 된다면 아마도 최적화가 가능했을 것입니다.

두번째로 collection은 동적입니다. 이는 collection에 새로운 item이 언제든지 추가될 수 있고, 또 언제든지 제거될 수 있다는 것을 의미합니다. Collection이 더이상 변경되지 않는다는것을 보장할 수 있다면 이 역시 최적화가 가능한 부분이기도 합니다.

이에 따라 .NET 8에서는 frozen collection이라는 새로운 개념을 도입하게 되었습니다. 현재 frozen collection은 향후에 더 추가될 수 있지만 FrozenDictionary<TKey, TValue>와 FrozenSet<T>가 존재합니다.

using System.Collections.Frozen;

Console.OutputEncoding = System.Text.Encoding.UTF8;

Dictionary<string, string> employees = new Dictionary<string, string>();
employees.Add("A1", "홍길순");
employees.Add("A2", "홍길동");
employees.Add("A3", "홍길영");

FrozenDictionary<string, string> frozenEmployee = employees.ToFrozenDictionary();

foreach(var item in frozenEmployee)
{
    Console.WriteLine(item.Key + ":" + item.Value);
}

위 예제는 기존 employees dictionary를 frozen dictionary로 변환한 뒤 각 item을 표시하도록 합니다.

지금까지의 내용에 따라 Add method의 동작은 type에 따라 달라진다는 것을 알 수 있습니다.

List<T> : 새로운 item은 list의 끝에 추가합니다.
Dictionary<TKey, TValue> : 새로운 item은 내부구조에 따라 결정된 위치에 추가합니다.
ReadOnlyCollection<T> : item추가가 지원되지 않으며 추가를 시도하는 경우 예외를 발생시키게 됩니다.
ImmutableList<T> : 새로 추가된 item을 포함한 새로운 list를 반환합니다. 본래 list에는 영향을 주지 않습니다.
ImmutableDictionary<TKey, TValue> : 새로 추가된 item을 포함한 새로운 list를 반환합니다. 본래 list에는 영향을 주지 않습니다.
FrozenDictionary<TKey, TValue> : 해당 method가 존재하지 않습니다.

frozen collection에 관한 더 많은 정보는 아래 link를 참고하시기 바랍니다.

System.Collections.Frozen Namespace | Microsoft Learn

System.Collections.Frozen Namespace

Explore all classes and interfaces of the System.Collections.Frozen namespace.

learn.microsoft.com

(9) Collection 표현식을 사용한 초기화

C# 11이전에는 collection, array, span등을 초기화 할때 int형인 경우 다음과 같은 방식을 사용했었습니다.

int[] myArray = { 1, 2, 3 };
List<int> MyList = new() { 1, 2, 3 };
Span<int> MyySpan = stackalloc int[] { 1, 2, 3 };

이것을 C# 12부터는 collection, array, span등을 초기화 할 수 있는 새로운 문법을 도입하게 되어 대괄호를 사용한 일관성있는 초기화가 가능해쪘습니다.

int[] myArray = [ 1, 2, 3 ];
List<int> MyList =  [ 1, 2, 3 ];
Span<int> MyySpan = [ 1, 2, 3 ];

(10) Collection에 대한 모범사례

Collection을 처리해야 하는 method를 만들어야 한다고 가정해 보면 예를 들어 최대한의 유용성을 활용하기 위해 입력 매개변수를 IEnumerable<T>로 선언하여 method를 generic으로 만들 수 있습니다.

void ProcessCollection<T>(IEnumerable<T> collection)
{
}

이렇게 하면 여기에 int나 string 또는 사용자 type 등 IEnumerable<T>를 구현하는 다른 모든 type을 포함하는 list, queue, stack과 같은 array를 전달할 수 있습니다. 그러나 해당 method로 모든 collection을 전달하고자 하는 이런 유연성은 꽤 많은 처리비용을 요구할 수 있습니다.

IEnumerable<T>로 하면 이에 대한 성능저하의 문제점으로 개체를 heap에 할당해야 하는 것으로 기인합니다. 이러한 memory할당을 피하려면 위의 method에서 아래와 같이 구체적인 type을 명시해야 합니다.

void ProcessCollection<T>(List<T> collection)
{

}

이렇게 하면 IEnumerator<T>에서 참조 type을 반환하는 GetEnumerator method대신 구조체를 반환하는 List<T>의 GetEnumerator method를 사용하게 됩니다. 이것만으로 2~3배 정도의 성능상향을 기대할 수 있으며 그만큼 memory로 더 적게 사용합니다. 성능과 관련된 다른 모든 권장사항들이 그렇듯이 실제 code를 test 함으로써 성능에 관한 이점을 확인해야 합니다.

5. Span, Index 그리고 range

.NET Core 2.1에서 Microsoft의 목표 중 하나는 성능 및 resource의 사용을 개선하는 것이었으며 이에 대한 핵심 .NET 기능이 Span<T> type입니다.

(1) Span을 통한 memory 효율성 증가

Array를 다룰 때 어떤 경우에는 기존의 것에서 일부만 따로 떼어낸 새로운 복사본이 필요할 때가 있습니다. 그런데 실제 이와 같은 복사본을 생성하는 것은 memory안에 동일한 같은 개체를 만들게 되므로 그리 효휼적이라고 할 수는 없습니다.

따라서 만약 기존 array에서 전체 혹은 부분적으로 동일한 array를 대신 사용해야 한다면 본래 array에 대한 거울과 같은 span을 사용할 수 있습니다. Memory사용율과 성능면에서 더 효율적인 span은 오로지 array에 대해서만 사용할 수 있으며 memory가 연속되어야 하므로 collection에서는 사용할 수 없습니다.

(2) Index type을 통한 위치 식별

C# 8.0에서는 array안에서 item의 위치와 2개의 index를 사용해 item의 범위를 식별하기 위한 2가지 기능을 도입했습니다.

list의 개체는 indexer에 int값을 전달함으로써 다음과 같이 접근할 수 있습니다.

int index = 3;
Person p = people[index];
char letter = name[index];

Index type은 아래와 같이 사용할 수 있으며 position을 식별하기 위한 공식적인 방법이고 또한 아래와 같이 끝에서부터 계산할 수 있는 fromEnd를 사용할 수 있습니다.

Index i1 = new(value: 3);
Index i2 = 3;

Index i3 = new(value: 5, fromEnd: true);
Index i4 = ^5;

index를 정의하기 위해서 예제와 같이 명시적으로 숫자를 사용하거나 new(value: 3)과 같이 사용할 수 있습니다. 이때 index는 시작부터 3번째를 의미합니다.

끝에서 부터 counting 되도록 하는 경우 fromEnd를 사용하거나 ^(caret) 문자를 사용합니다.

(3) Range type으로 범위 식별하기

Range type은 범위의 시작과 끝을 나타내기 위해 Index값을 사용하며 생성자 혹은 정적 method를 사용해 생성합니다.

Range r1 = new(start: new Index(3), end: new Index(7));
Range r2 = new(start: 3, end: 7);
Range r3 = 3..7;
Range r4 = Range.StartAt(3);
Range r5 = 3..;
Range r6 = Range.EndAt(3); 
Range r7 = ..3;

기본적으로 range type은 위 예제에서 첫 번째와 두 번째같이 생성자를 통해 생성할 수 있습니다. 세 번째는 C# 8부터 사용가능한 방식이며 네번째는 정적 method를 사용한 것으로 세번째 index부터 끝까지를 의미합니다. 다섯번째는 네번째와 의미가 같고 여섯번째는 끝에서 부터 세번째 index를 의미합니다. 일곱 번째는 여섯 번째와 같습니다.

확장 method는 문자열값(내부적으로 char 배열을 사용), int array 그리고 span에 추가되어 범위를 더 쉽게 다룰 수 있습니다. 이들 확장 method는 매개변수로 범위를 수용하고 Span<T>를 반환함으로써 memory를 더 효휼적으로 사용할 수 있도록 합니다.

(4) Indexe, range, 그리고 span사용하기

Span을 반환하는 index와 range는 아래와 같이 사용할 수 있습니다.

csStudy08 solution에서 WorkingWithRanges이름의 Console app project를 생성하고 Program.cs에서 기존의 문을 모두 삭제한 뒤 string type의 substring method에서 범위를 지정하여 이름을 추출하고 비교하는 문을 추가합니다.

string name = "Gildong hong";

//성과 이름의 길이를 확인합니다.
int lengthOfFirst = name.IndexOf(' ');
int lengthOfLast = name.Length - lengthOfFirst - 1;

//성과 이름을 분리해 가져옵니다.
string firstName = name.Substring(startIndex: 0, length: lengthOfFirst);
string lastName = name.Substring(startIndex: name.Length - lengthOfLast, length: lengthOfLast);

Console.WriteLine($"First name: {firstName}, Last name: {lastName}");

위의 예제를 span을 사용해 구현하면 다음과 같이 할 수 있습니다.

ReadOnlySpan<char> nameAsSpan = name.AsSpan();
ReadOnlySpan<char> firstNameSpan = nameAsSpan[0..lengthOfFirst];
ReadOnlySpan<char> lastNameSpan = nameAsSpan[^lengthOfLast..^0];

Console.WriteLine("First name: {0}, Last name: {1}", arg0: firstNameSpan.ToString(), arg1: lastNameSpan.ToString());

예제를 실행하면 결과를 다음과 같을 것입니다.

5. Network Resource

외부와의 통신이 필요한 application이라면 network와 관련된 여러 가지 작업이 필요합니다. 아래 표는 그런 경우 사용가능한 type을 나열한 것입니다.

Namespace	Type	Description
System.Net	Dns, Uri, Cookie, WebClient, IPAddress	DNS server, URIs, IP address관련및 기타
System.Net	FtpStatusCode, FtpWebRequest, FtpWebResponse	FTP server 관련
System.Net	HttpStatusCode, HttpWebRequest, HttpWebResponse	HTTP server와 관련된 것으로서 website와 service등을 의미
System.Net.Http	HttpClient, HttpMethod, HttpRequestMessage, HttpResponseMessage	HTTP server와 관련된 것으로서 website와 service등을 의미
System.Net.Mail	Attachment, MailAddress, MailMessage, SmtpClient	Mail을 발송하는 SMTP server관련
System.Net .NetworkInformation	IPStatus, NetworkChange, Ping, TcpStatistics	저수준 network protocol관련

(1) URI, DNS, IP 주소

Network resource를 사용하는 예를 작성하기 위해 csStudy08 solution에서 WorkingWithNetworkResources이름의 Console App을 생성하고 Program.cs에서 기존의 문을 모두 삭제한 뒤 아래의 namespace를 import 합니다.

using System.Net;

그리고 Program.cs에서 사용자에게 website주소의 입력을 요청하고 주소가 입력되면 Uri type을 사용해 해당 주소를 HTTP, FTP 등의 scheme, port 번호, host 등 각각의 요소로 분해하는 문을 아래와 같이 추가합니다.

Console.Write("Enter a valid web address (or press Enter): ");

string? url = Console.ReadLine();
if (string.IsNullOrWhiteSpace(url))
{
    url = "http://cliel.com/";
}

Uri uri = new(url);
Console.WriteLine($"URL: {url}");
Console.WriteLine($"Scheme: {uri.Scheme}");
Console.WriteLine($"Port: {uri.Port}");
Console.WriteLine($"Host: {uri.Host}");
Console.WriteLine($"Path: {uri.AbsolutePath}");
Console.WriteLine($"Query: {uri.Query}");

예제를 실행하고 정확한 website주소를 입력하게 되면 아래와 같은 결과를 확인할 수 있습니다.

이어서 입력된 website주소에 대한 ip를 확인할 수 있는 문을 추가합니다.

IPHostEntry entry = Dns.GetHostEntry(uri.Host);
Console.WriteLine($"{entry.HostName} has the following IP addresses:");
foreach (IPAddress address in entry.AddressList)
{
    Console.WriteLine($" {address} ({address.AddressFamily})");
}

예제를 실행하고 정확한 website주소를 입력하면 다음의 결과를 표시할 것입니다.

(2) Server로 ping 보내기

위 예제에서 입력된 website주소의 web server 상태는 ping응답을 받음으로써 확인할 수 있습니다. Program.cs에서 이를 구현하기 위한 code를 아래와 같이 추가합니다.

Console.WriteLine($"Host: {uri.Host}");

Ping ping = new();
Console.WriteLine("Pinging server. Please wait...");

PingReply reply = ping.Send(uri.Host);
Console.WriteLine($"{uri.Host} was pinged and replied: {reply.Status}.");

if (reply.Status == IPStatus.Success)
{
    Console.WriteLine("Reply from {0} took {1:N0}ms", arg0: reply.Address, arg1: reply.RoundtripTime);
}

예제를 실행하고 정확한 website주소를 입력해 보면 다음의 결과를 표시할 것입니다.

[C# 12와 .NET 8] 7. .NET Packaging과 배포

클리엘 — Tue, 20 Feb 2024 09:11:50 +0900

C# 키워드가 .NET 유형과 어떻게 관련되어 있는지, 네임스페이스와 어셈블리 간에는 어떤 관계가 있는지에 대한 것을 알면 C#언어를 이해하는데 도움이 될 수 있습니다. 또한 .NET library에서 이전 .NET framework library를 어떻게 사용하고 이식할 수 있는지의 여부도 함께 알아볼 것이며 이를 통해 .NET을 좀더 폭넓게 활용할 수 있을 것입니다.

1. .NET 8

.NET에서는 Base Class Library (BCL) API를 통해 수 많은 기능들을 제공하고 있습니다. .NET Standard를 통해서는 다른 전체 .NET platform간 이런 기능들을 재사용할 수 있도록 하고 있는데 때문에 지금의 .NET과 이전의 것을 적절히 이해해둘 필요가 있습니다.

.NET Standard 2.0의 최소규격을 지원하는 .NET Core 2.0부터는 .NET Core의 첫번째 version에는 없던 많은 API를 제공하고 있으므로 여기서 부터가 중요한 전환점이 될 수 있습니다. .NET Framework 개발자가 최신의 개발과 관련하여 15년간 이용할 수 있었던 library와 application은 지금 .NET과 통합되었고 Windows는 물론 macOS와 다양한 Linux에서 동작할 수 있습니다.

.NET Standard 2.1은 3,000여개의 새로운 API가 추가되었는데 이들 중 몇몇은 이전 version과의 호환성을 깨는 runtime의 변경이 필요했습니다. 따라서 .NET Framework 4.8은 .NET Standard 2.0만을 구현하며 .NET Core 3.0, Xamarin, Mono, 그리고 Unity는 .NET Standard 2.1을 구현하게 되었습니다.

.NET 5에 들어서는 project에서 .NET 5만을 사용한다면 .NET Standard의 필요성을 제거할 수 있게 되었고 이는 .NET 6, .NET 7에서도 동일합니다. 하지만 여전히 .NET Framework project와 Xamarin mobile app을 생성해야 하는 경우도 있으므로 지금도 .NET Standard 2.0과 2.1 class library를 생성할 수 있습니다.

현재 .NET 6와 .NET 7은 자체 .NET MAUI를 통해 완벽하게 mobile과 desktop app을 지원하고 있는데 이로서 .NET Standard의 필요성은 점차 감소하고 있습니다.

아래는 지난 5년동안의 .NET의 진행상황을 요약하기 위해 주요 .NET Core와 최신 .NET을 동등한 .NET Framework와 비교한 것입니다.

.NET Core 1.x : 2016년 3월이 현재 version이며 .NET Framework 4.6.1에 비해 훨씬 작은 API를 가지고 있습니다.
.NET Core 2.x : .NET Framework 4.7.1과 동일하게 .NET Standard 2.0을 구현함으로서 동등한 API에 도달하였습니다.
.NET Core 3.x : .NET Framework 4.8에서 구현하지 않은 .NET Standard 2.1을 구현함으로서 월씬 더 많은 API를 지원하게 되었습니다.
.NET 5 : 상당히 향상된 성능과 함께 더 .NET Framework 4.8에 비해 더 많은 API를 지원합니다.
.NET 6 : 지속적인 성능 향상과 API확장을 이루었으며 2022년 5월에 추가된 .NET MAUI를 통해 mobile app을 지원할 수 있게 되었습니다.
.NET 7 : .NET MAUI로 mobile app지원을 위한 최종 통합 version입니다.
.NET 8 : 지속적인 성능 향상이 이루어지고 있으며 모든 신규 project에 적용할 수 있습니다.

(1) .NET Core 1.0

2016년 6월에 release 되었으며 ASP.NET Core를 사용하는 Linux용 web과 cloud application 그리고 service를 포함한 최신의 cross-platform app개발을 위해 안정적인 API를 제공하는데 초점이 맞춰진 version입니다.

(2) .NET Core 1.1

2016년 11월에 release 되었으며 bug를 수정하고 지원되는 Linux의 배포한 수를 증가되었으며 .NET Standard 1.6를 지원하게 되었습니다. 또한 성능의 증가도 이루어졌는데 특히 web app과 service를 위한 ASP.NET Core에서 큰 성능향상이 이루어졌습니다.

(3) .NET Core 2.0

2017년 8월에 release되었으며 .NET Standard 2.0을 구현하였고 .NET Framework library를 참조하고 더 많은 성능향상을 이루었습니다.

(4) .NET Core 2.1

2018년 5월에 release 되었으며 확장가능한 tooling system(사용 목적에 따라 각각의 도구(기능)를 선택/조합하는 체계)에 중점을 두었습니다. Span<T>, 암호화 및 압축 그리고 예전 windows application을 이식하는데 필요한 20,000가지의 추가적인 API와 함께 Windows Compatibility Pack, Entity Framework Core값 변환, LINQ GroupBy 변환, data seeding, query type과 같은 새로운 type이 추가되었으며 아래 표의 기능을 포함해 전반적인 성능 향상이 이루어졌습니다.

기능	내용
Spans	-
Brotli compression	Brotli algorithm을 통한 압축방식
EF Core Lazy loading	lazy(지연) loading 사용
EF Core Data seeding	-

(5) .NET Core 2.2

2018년 12월에 release 되었으며 runtime에서의 진단향상, 선택적 계층 compile등에 중점을 두었으며 ASP.NET Core과 Entity Framework에 NetTopologySuite (NTS) library, query tag, 소유 entity collection 등의 type을 사용하는 공간 data지원등 새로운 기능이 추가되었습니다.

(6) .NET Core 3.0

2019년 9월에 release 되었으며 Windows forms, WPF(Windows Presentation Foundation) 그리고 Entity Framework 6.3, side-by-side와 app-local 개발, fast JSON reader, serial port 접근, IoT(Internet of Things) solution을 위한 pinout 접근등을 사용하는 desktop application구축하는데 필요한 지원에 중점을 두었습니다. 또한 아래 기능을 포함해 기본 계층 compile이 추가되었습니다.

기능	내용
Embedding .NET in-app	-
Index and Range	-
System.Text.Json	고성능 JSON 처리

(7) .NET Core 3.1

2019년 12월에 release 되었으며 bug수정과 개선에 초점이 맞춰져 Long Term Support (LTS)가 되었고 이로서 2022년 12월까지 지원이 이루어졌습니다.

(8) .NET 5.0

2020년 10월에 release 되었으며 mobile을 제외한 다양한 .NET platform을 통합하는데 주력하였습니다. platform을 개선하고 아래 표의 기능을 포함해 전반적으로 성능향상이 이루어졌습니다.

기능	내용
Half type	반정밀도 부동 소수점 숫자
정규 표현식 성능 향상	정규 표현식 성능 향상
System.Text.Json 향상	고성능 JSON 처리
EF Core generated SQL	-
EF Core Filtered Include	Entity filtering
EF Core의 Humanizer 통합	-

(9) .NET 6.0

2021년 10월에 release 되었으며 data관리를 위한 EF Core로 더 많은 기능과 함께 시간과 날짜에 관한 새로운 type이 추가되었습니다. 또한 아래 표의 기능을 포함해 전반적인 성능향상이 이루어졌습니다.

기능	내용
.NET SDK 상태 확인	.NET SDK update 확인
Apple Silicon 지원	배포가능한 console application 생성가능
Link trim mode 기본 사용	app trimming을 통한 app size 감소
List<T>에 대한 EnsureCapacity	collection용량 확보를 통한 성능 향상
RandomAccess를 사용하는 저수준 file API	-
EF Core 구성 규칙	-
새로운 LINQ method	-
TryGetNonEnumeratedCount	-

(10) .NET 7.0

2022년 10월에 release 되었으며 mobile platform을 통합하고 string syntax coloring과 IntelliSense 같은 새로운 기능이 추가되었습니다. tar 형식의 압축을 생성하거나 풀어낼 수 있게 되었고 EF Core를 통한 insert와 upate성능이 향상되었습니다.

기능	내용
[StringSyntax] attribute	regular expression syntax coloring 활성화
[GeneratedRegex] attribute	source generator를 통한 정규 표현식 성능 향상
Tar archive support	tar 압축 file
ExecuteUpdate와 ExecuteDelete	더욱 효과적인 update및 삭제
Order와 OrderDescending	item 자체 정렬

(11) .NET 8.0

C# 12 및 F# 8 언어의 새로운 기능과 개선 사항을 포함하고 있으며 Dynamic Profile-Guided Optimization (PGO)이라는 새로운 코드 생성기를 도입하여 실제 사용에 기반한 코드 최적화를 이룰 수 있습니다. 실제 이를 통해 통해 애플리케이션 성능을 최대 20%까지 향상시킬 수 있습니다. 이 밖에 AI사용을 위한 기능이 강화되었습니다.

(12) .NET 5 이후의 성능 향상

Microsoft는 지난 몇년간 .NET에 대한 상당한 성능향상을 이루어 왔습니다. 이와 관련된 상세한 내용은 아래 글을 통해 확인하실 수 있습니다.

Performance Improvements in .NET 5 - .NET Blog (microsoft.com)

Performance Improvements in .NET 5 - .NET Blog

Explore many performance improvements, big and small, that have gone into the .NET 5 runtime and core libraries to make apps and services leaner and faster.

devblogs.microsoft.com

Performance Improvements in .NET 6 - .NET Blog (microsoft.com)

Performance Improvements in .NET 6 - .NET Blog

Take a rip-roarin' tour through hundreds of PRs worth of performance improvements for .NET 6.

devblogs.microsoft.com

Performance Improvements in .NET 7 - .NET Blog (microsoft.com)

Performance Improvements in .NET 7 - .NET Blog

.NET 7 is fast. Really fast. This post deep-dives into hundreds of performance improvements that contributed to that reality.

devblogs.microsoft.com

Performance Improvements in .NET 8 - .NET Blog (microsoft.com)

Performance Improvements in .NET 8 - .NET Blog

.NET 7 was super fast, .NET 8 is faster. Take an in-depth tour through over 500 pull requests that make that a reality.

devblogs.microsoft.com

(13) Update를 위한 .NET SDK 확인

.NET 6에서 부터 Microsoft는 설치 SDK와 runtime의 version을 확인하기 위한 명령을 추가했고 이를 통해 update가 필요하다고 확인되는 경우 이를 알려줄 수 있습니다.

명령은 아래와 같으며

dotnet sdk check

다음과 같은 경우처럼 update가 필요한 항목을 확인할 수 있습니다.

.NET SDKs:
Version      Status
------------------------
8.0.101      Up to date.

.NET Runtimes:
Name                              Version      Status
-------------------------------------------------------------------------------------
Microsoft.NETCore.App             5.0.17       .NET 5.0 is out of support.
Microsoft.NETCore.App             6.0.7        Patch 6.0.26 is available.
Microsoft.WindowsDesktop.App      6.0.7        Patch 6.0.26 is available.
Microsoft.NETCore.App             6.0.10       Patch 6.0.26 is available.
Microsoft.WindowsDesktop.App      6.0.10       Patch 6.0.26 is available.
Microsoft.NETCore.App             6.0.11       Patch 6.0.26 is available.
Microsoft.WindowsDesktop.App      6.0.11       Patch 6.0.26 is available.
Microsoft.NETCore.App             6.0.12       Patch 6.0.26 is available.
Microsoft.WindowsDesktop.App      6.0.12       Patch 6.0.26 is available.
Microsoft.NETCore.App             6.0.13       Patch 6.0.26 is available.
Microsoft.WindowsDesktop.App      6.0.13       Patch 6.0.26 is available.
Microsoft.AspNetCore.App          6.0.14       Patch 6.0.26 is available.
Microsoft.NETCore.App             6.0.15       Patch 6.0.26 is available.
Microsoft.WindowsDesktop.App      6.0.15       Patch 6.0.26 is available.
Microsoft.AspNetCore.App          6.0.26       Up to date.
Microsoft.NETCore.App             6.0.26       Up to date.
Microsoft.WindowsDesktop.App      6.0.26       Up to date.
Microsoft.NETCore.App             7.0.3        .NET 7.0 is going out of support soon.
Microsoft.WindowsDesktop.App      7.0.3        .NET 7.0 is going out of support soon.
Microsoft.AspNetCore.App          7.0.15       .NET 7.0 is going out of support soon.
Microsoft.NETCore.App             7.0.15       .NET 7.0 is going out of support soon.
Microsoft.WindowsDesktop.App      7.0.15       .NET 7.0 is going out of support soon.
Microsoft.AspNetCore.App          8.0.1        Up to date.
Microsoft.NETCore.App             8.0.1        Up to date.
Microsoft.WindowsDesktop.App      8.0.1        Up to date.

The latest versions of .NET can be installed from https://aka.ms/dotnet-core-download. For more information about .NET lifecycles, see https://aka.ms/dotnet-core-support.

2 .NET Component

.NET은 아래와 같은 요소로 이루어져 있습니다.

Language compiler : C#이나 F#등으로 된 source code를 assembly로 저장된 IL code로 변환시킵니다. C# 6.0 이후부터는 compiler를 Roslyn이라는 이름으로 open-source화 하였습니다.
Common Language Runtime(CoreCLR) : Assembly를 load 하여 해당 assembly에 저장된 IL code를 해당 computer의 CPU에 맞는 native code로 compile한뒤 thread와 memory 같은 관리 resource환경 안에서 code를 실행하게 됩니다.
Base Class Libraries(BCL 또는 CoreFX) : Application을 구축할 때 공통적인 동작을 수행하기 위해 Nuget을 통하여 package 및 배포된 type의 사전 build 된 assembly를 포함할 수 있습니다. 이를 사용하여 LEGO 부품을 조립하듯 필요한 것을 빠르고 안정적으로 구축할 수 있습니다.

(1) Assembly, NuGet package, namespace

Assembly는 type이 filesystem으로 저장된 것입니다. Code를 배포하기 위한 mechanism인데 예를 들어 System.Data.dll assembly는 data를 관리하기 위한 type을 포함하고 있습니다. 다른 assembly의 다른 type을 사용하기 위해서는 해당 assembly가 참조되어 있아야 하며 이때 assembly는 정적(pre-created) 또는 동적(generated at runtime)인 것이 될 수 있습니다. 또한 assembly는 class library인 dll이나 console app과 같은 exe의 단일 file로 compile 될 수도 있습니다.

Assembly는 NuGet package를 통해 내려받기 가능하도록 배포될 수 있으며 이때 다수의 assembly나 다른 resource를 포함할 수 있습니다.

Microsoft NuGet feed는 아래 주소에서 찾을 수 있습니다.

NuGet Gallery | Home

The NuGet Gallery is the central package repository for NuGet, the package manager for .NET.

www.nuget.org

● Namespace

Namespace는 type의 주소입니다. 단순한 이름대신 주소체계를 사용함으로써 type을 식별하기 위한 mechanism으로 활용됩니다.

한 가지 예로 .NET에서 System.Web.Mvc namespace의 interface인 IActionFilter는 System.Web.Http.Filters namespace의 IActionFilter에 비해 namespace가 다르므로 다른 interface로 구별될 수 있습니다.

● Assembly 의존성

Assembly가 class library로 compile 되고 다른 assembly에서의 사용을 위해 이를 제공하게 된다면 이때 file은 .dll 확장자를 가지게 되며 독립적으로 실행될 수 없습니다.

마찬가지로, assembly가 application으로 compile 되면 이때는 exe확장자를 가지게 되며 독립적으로 실행가능한 상태가 됩니다. (.NET Core 3.0이전에 console app은 dll file로 compile 되었으며 이때는 dotnet run 명령을 통해 실행될 수 있었습니다.)

모든 assembly는 하나 또는 그 이상의 class library를 의존성으로 참조할 수 있습니다. 하지만 소위 순환참조는 불가능하기 때문에 예를 들어 B라는 assembly는 A라는 assembly에서 이미 B assembly를 참조하고 있다면 A assembly를 참조할 수 없습니다. 때문에 compiler는 순환참조를 유발할 수 있는 의존성 참조를 추가하려고 한다면 경고를 표시하게 됩니다. 대게는 오래전에 작성된 code에서 순환참조에 대한 오류가 나오기 쉬우며 만약 정말 순환참조가 필요한 상황이 온다면 이는 interface로 관련 문제를 해결하는 것이 좋습니다.

(2) Microsoft .NET Project SDK

기본적으로 console application은 Microsoft .NET project SDK에 대한 의존성 참조를 가지고 있습니다. 이 platform은 NuGet package에서 거의 대부분의 application에서 필요로 하는, 예를 들어 System.Int32나 System.tring type과 같은 수천 개의 type들을 포함하고 있으며 .NET을 사용할 때는 project file에서 필요로 하는 의존성 assembly와 NuGet package 그리고 platform 등을 참조하게 됩니다.

(3) Assembly에서 namespace와 type

대부분의 일반적인 .NET type은 System.Runtime.dll assembly에 있으며 assembly와 namespace는 항상 1:1로 mapping 되지는 않습니다. 단일 assembly라도 다수의 namespace를 포함할 수 있으며 namespace는 다수의 assembly에서 정의될 수 있습니다. 아래 표는 type을 지원하기 위해 사용되는 일부 assembly와 namespace 간 연관성을 나타내고 있습니다.

Assembly	사용 Namespace	제공 Type
System.Runtime.dll	System, System.Collections, System.Collections.Generic	Int32, String, IEnumerable<T>
System.Console.dll	System	Console
System.Threading.dll	System.Threading	Interlocked, Monitor, Mutex
System.Xml.XDocument.dll	System.Xml.Linq	XDocument, XElement, XNode

(4) NuGet package

.NET은 하나가 아닌 몇 개의 package별로 나누어졌고 이를 NuGet이라는 package 관리 기술을 사용해 게시하였습니다. 이렇게 게시된 각각의 package들은 같은 이름의 단일 assembly로 표현됩니다. 예를 들어 System.Collections package는 System.Collections.dll assembly를 포함합니다.

Package는 다음과 같은 장점 및 특징을 가집니다.

공개 feed(패키지를 인터넷의 모든 사용자와 공개적으로 공유하는 데 사용)에 쉽게 게시할 수 있습니다.
재사용이 가능합니다.
자체 일정에 따라 게시될 수 있습니다.
다른 package와 독립적으로 test 될 수 있습니다.
같은 assembly를 다른 OS와 CPU에 따라 build 한 여러 version을 포함시킴으로써 다른 OS와 CPU를 지원할 수 있습니다.
하나의 library에 대해서만 특정한 종속성을 가질 수 있습니다.
참조되지 않은 package는 배포의 일부가 아니므로 app은 더 작아질 수 있습니다. 아래 표는 가장 중요한 package와 해당 package에서 중요한 type의 일부를 나타낸 것입니다.

Package	중요 type
System.Runtime	Object, String, Int32, Array
System.Collections	List<T>, Dictionary<TKey, TValue>
System.Net.Http	HttpClient, HttpResponseMessage
System.IO.FileSystem	File, Directory
System.Reflection	Assembly, TypeInfo, MethodInfo

(5) Framework

Package는 API를 정의하며 framework는 이런 package를 group화 합니다. 어떠한 package도 없는 framework는 어떠한 API도 정의하지 않습니다.

.NET package는 각각 일련의 framework를 지원합니다. 예를 들어 System.IO.FileSystem package version 4.3.0은 아래 framework를 지원합니다.

.NET Standard, version 1.3 이후
.NET Framework, version 4.6 이후
Six Mono와 Xamarin platform (Xamarin.iOS 1.0)

좀 더 상세한 내용은 아래 주소를 참조하시기 바랍니다.

NuGet Gallery | System.IO.FileSystem 4.3.0

System.IO.FileSystem 4.3.0

Provides types that allow reading and writing to files and types that provide basic file and directory support. Commonly Used Types: System.IO.FileStream System.IO.FileInfo System.IO.DirectoryInfo System.IO.FileSystemInfo System.IO.File System.IO.Directory

www.nuget.org

(6) Type 사용을 위한 namespace importing

예제를 통해 namespace가 assembly와 type에 어떻게 관련되는지를 알아보도록 하겠습니다. csStudy07 이름의 빈 solution을 생성하고 그 안에 'AssembliesAndNamespaces'이름의 project를 추가합니다.

AssembliesAndNamespaces의 Program.cs에서 기존 구문을 모두 삭제하고 아래와 같이 XDocument type의 instance를 생성하는 문을 추가합니다.

XDocument doc = new();

이 상태에서 Project를 build 하면 다음과 같은 compiler error message가 발생하게 됩니다.

The type or namespace name 'XDocument' could not be found (are you missing a using directive or an assembly reference?)

XDocument type은 우리가 compiler에게 해당 type의 namespace가 무엇인지를 알려주지 않았기 때문에 인식될 수 없습니다. 설령 project가 type을 포함하고 있는 assembly를 참조하고 있다고 하더라도 type이름에 namespace에 대한 접두사를 붙이거나 해당 namespace를 import 해야 합니다.

XDocument class의 이름에 mouse를 대면 하단에 풍선도움말이 표시되는데 이때 'Show potential pixes'를 click한뒤 menu에 나오는 System.Xml.Linq를 선택하면 자동적으로 해당 Namespace가 file의 상단에 using문을 추가함으로써 import 될 것입니다. 일단 namespace가 import 되고 나면 namespace에 속하는 모든 type은 code에서 namespace전체를 붙여줄 필요 없이 이름만 입력하는 것으로 사용가능하게 됩니다.

Visual Studio를 사용하는 것이라면 위에서 처럼 type을 입력하는 것만으로 인식가능한 namespace를 자동으로 import 해줄 것입니다.(2022 version부터)

(7) C# keyword와 .NET type의 연결

C#에서는 문자열을 다루는 keyword가 2가지가 있는데 하나는 string이고 다른 하나는 String입니다. 이 둘의 차이는 소문자 s와 대문자 S 뿐이며 사실상 용도와 동작에 있어서는 아무런 차이가 없습니다. int와 string과 같은 C# keyword는 class library assembly에 있는 .NET Type의 별칭입니다.

따라서 string keyword를 사용하는 경우에 compiler는 이를 System.String type으로 인식하게 되고 int를 사용하는 경우에는 System.Int32 type으로 인식합니다. 문자열을 다루기 위해 String이라고 하는 것보다는 string으로 사용하는 것이 더 익숙하고 편리한 면이 있으며 Int32보다는 int로 사용하는 것도 같은 이유기 때문에 좀 더 편리한 code의 작성을 위해 별칭으로 따로 만들어둔 것입니다.

Program.cs에서 문자열값을 가진 2개의 변수를 선언하는데 하나는 string으로 다른 하나는 String으로 선언합니다.

string s1 = "Hello";
String s2 = "World";
Console.WriteLine($"{s1} {s2}");

위 예제를 실행하면 두 변수는 정확히 동일하게 취급되어 동일한 처리를 하게 됩니다.

Project의 csproj file에서 전역적으로 import 되는 System namespace를 사용하지 않도록 하는 요소를 아래와 같이 추가합니다.

<ItemGroup>
	<Using Remove="System" />
</ItemGroup>

그러면 아래와 같이 compiler 오류가 발생할 것입니다.

이를 통해 String은 System namespace의 String type을 사용한다는 것을 알 수 있습니다.

실제 String과 같은 type대신 C# keyword를 사용하면 위에서와 같이 해당 type의 namespace import를 신경 쓰지 않아도 됩니다.

● C# 별칭과 .NET type의 Mapping

아래 표는 18가지 C# type keyword와 같이 연결된 .NET Type을 나타내고 있습니다.

Keyword	.NET type	Keyword	.NET type
string	System.String	char	System.Char
sbyte	System.SByte	byte	System.Byte
short	System.Int16	ushort	System.UInt16
int	System.Int32	uint	System.UInt32
long	System.Int64	ulong	System.UInt64
nint	System.IntPtr	nuint	System.UIntPtr
float	System.Single	double	System.Double
decimal	System.Decimal	bool	System.Boolean
object	System.Object	dynamic	System.Dynamic.DynamicObject

다른 .NET Programming 언어 compiler도 같은 방식을 사용할 수 있습니다. 예를 들어 VB.NET의 경우에는 Integer라는 이름의 type을 가지고 있으며 이는 System.Int32의 별칭으로 연결됩니다.

● native-sized integers

C# 9에서는 native-sized integers에 대한 별칭에 해당하는 nint와 nuint를 도입하였습니다. 여기서 저장되는 integer값의 크기는 platform에 따라 다릅니다. 따라서 32bit process에서는 32bit integer로 저장되며 sizeof()에서는 4byte를 반환하고 64bit process에서는 64bit integer로, sizeof()에서는 8byte를 반환합니다. 해당 별칭의 이름이 IntPtr/UIntPtr인데 이를 통해 해당 별칭은 integer값이 저장된 memory의 위치를 나타낸다는 것을 알 수 있으며 실제 저장되는 type은 process에 따라 System.Int32 또는 System.Int64가 됩니다.

Console.WriteLine($"int.MaxValue = {int.MaxValue:N0}");
Console.WriteLine($"nint.MaxValue = {nint.MaxValue:N0}");

● Type의 위치 표시

Visual Studio에서 아래와 같이 string이나 String의 변수를 생성하고

string s;

해당 type을 선택한 뒤 mouse오른쪽 button을 눌러 'Go to Definition'을 선택합니다.

Code editor를 보면 assembly file명은 'System.Runtime.dll'이지만 class는 System namespace에 있음을 알 수 있습니다.

그런데 지난 글에서

[.NET/C#] - [C# 12와 .NET 8] 2. C#

System.Runtime.dll에 포함된 type은 0 임을 언급한 바 있습니다.

System.Runtime.dll assembly가 포함하고 있는 것은 type-forwarder입니다. 이들은 assembly안에 포함되어 있는 것처럼 표시하지만 다른 곳에 구현되어 있는 특별한 type입니다. 이 경우 string은 고도로 최적화된 code를 사용해 .NET runtime내부에 깊이 구현되어 있습니다.

(8) .NET Standard를 사용한 legacy platform과의 code공유

.NET Standard 이전에는 PCL(Portable Class Libraries)가 있었습니다. PCL에서는 code의 library를 만들고 명시적으로 library에서 지원할 Xamarin, Silverlight, Windows 등의 platform을 지정할 수 있었고, 그렇게 하면 library는 지정된 platform에 의해서 지원되는 API와의 상호작용에 사용될 수 있었습니다.

하지만 Microsoft는 이것이 지속가능하리라고 판단하지 않고 미래 모든 .NET platform에서 지원할 단일 API인 .NET Standard를 생성하게 됩니다. .NET Standard에 이어 .NET Standard 2.0에서는 중요한 최신 .NET platform의 통합을 시도했고 2019년 말에 발표된 .NET Standard 2.1에서는 .NET Core 3.0과 그해 Xamarin에서만이 새로운 기능을 지원했습니다. (앞으로 언급되는 .NET Standard는 .NET Standard 2.0을 의미합니다.)

.NET Standard는 HTML5와 같이 둘다 platform이 지원할 수 있는 표준에 해당합니다. Google의 Chrome browser나 Microsoft의 Edge browser가 HTML5의 표준을 구현하듯 .NET Core, .NET Framework 그리고 Xamarin은 모두 .NET Standard를 구현합니다. 만약 다양한 legacy .NET에 걸쳐 작동하는 type의 library를 만들고자 한다면 .NET Standard를 통해 가장 쉽게 구현할 수 있습니다.

.NET Standard 2.1에서 많은 API가 추가되어 runtime의 변화가 필요했으며 .NET Framework는 가능한 한 변화 없이 유지되어야 할 Microsoft의 legacy platform이므로 .NET Framework 4.8에서는 .NET Standard 2.1을 구현하기 보다는 .NET Standard 2.0에서 남아있습니다. 만약 .NET Framework에서 지원되어야 할 필요가 있다면 비록 최신의 version이 아니고 모든 최근의 언어와 BCL의 새로운 기능을 지원하지 않지만 .NET Standard 2.0상의 class library를 만들 수 있습니다.

어떤 .NET Standard version을 목표로 할지에 대한 선택에서는 지원하고자 하는 platform과 가능한 기능사이에 균형을 맞추는 것이 중요합니다. 하위 version은 더 많은 platform을 지원하지만 더 작은 API를 갖게 됩니다. 상위 version은 적은 platform을 지원하지만 더 많은 API를 가질 수 있습니다. 일반적으로는 필요로 하는 모든 API를 지원하는 선에서 하위 version을 선택할 수 있습니다.

(9) 다른 SDK를 사용하는 class library의 기본 framework

Class library를 만들기 위해 dotnet SDK tool을 사용할 때 어떤 framework가 기본적으로 사용될지 알고 있을 필요가 있습니다. 아래 표는 이를 간략히 나타내고 있습니다.

SDK	새로운 class library에 사용될 기본 target framework
.NET Core 3.1	netstandard2.0
.NET 6	net6.0
.NET 7	net7.0
.NET 8	net8.0

물론 class library가 기본적으로 특정 .NET의 version을 대상으로 한다 하더라도 이것이 기본 template을 사용해 class library project를 생성한 이후에는 바꿀 수 없다는 것을 의미하는 것은 아닙니다.

설정에 의해 target framework를 library참조가 필요한 project에서 지원하는 값으로 바꿀 수 있습니다.

Class library target framework	project에서 사용할 수 있는 대상
netstandard2.0	.NET Framework 4.6.1이후, .NET Core 2.0이후, .NET 5.0이후, Mono 5.4이후, Xamarin.Android 8.0이후, Xamarin.iOS 10.14이후
netstandard2.1	.NET Core 3.0이후, .NET 5.0이후, Mono 6.4이후, Xamarin.Android 10이후, Xamarin.iOS 12.16이후
net6.0	.NET 6.0이후
net7.0	.NET 7.0이후
net8.0	.NET 8.0이후

Class library의 대상 framework를 확인하고 필요하다면 더 적절한 것으로 바꿀 수 있습니다. 기본값을 그대로 수용하기보다는 무엇이 적합한지 의식적으로 결정을 내리시면 됩니다.

(10) .NET Standard 2.0 class library를 만들기

.NET Standard 2.0을 사용해 모든 .NET legacy platform과 Windows 및 macOS, Linux OS의 cross-platform에서 사용가능하며 다양한 .NET API에 access 할 수 있는 class library를 만들어볼 것입니다.

csStudy07 solution에 SharedLibrary이름의 Class Library유형의 project를 추가합니다. 이때 .NET Standard 2.0을 target으로 설정해야 합니다.

만약 .NET Standard 2.0 기능만 사용하는 type뿐만 아니라 .NET 7의 새로운 기능을 사용하는 type을 생성해야 한다면 이 두 개의 class library를 분리하여 생성해야 합니다.

2개의 class library를 생성하는 대신 multi-targeting을 지원하는 방법도 존재합니다. 자세한 내용은 아래 link를 참고하시기 바랍니다.

Cross-platform targeting for .NET libraries | Microsoft Learn

Cross-platform targeting for .NET libraries

Best practice recommendations for creating cross-platform .NET libraries.

learn.microsoft.com

(11) .NET SDK 제어

기본적으로 dotnet 명령줄 실행에서는 system에 설치된 가장 최신의 .NET SDK를 사용합니다. 그러나 때로는 이렇게 사용되는 SDK를 변경해야 하는 경우가 있습니다. 그리고 이것은 global.json file을 사용함으로써 가능한데 dotnet명령은 global.json file을 현재 folder와 상위 folder에거 검색합니다.

지금부터 설명하는 절차를 굳이 따라 할 필요는 없지만 그래도 해보고자 한다면 .NET 6.0 SDK를 설치해야 하며 아래 link로부터 가져올 수 있습니다.

Download .NET 6.0 (Linux, macOS, and Windows) (microsoft.com)

Download .NET 6.0 (Linux, macOS, and Windows)

.NET 6.0 downloads for Linux, macOS, and Windows. .NET is a free, cross-platform, open-source developer platform for building many different types of applications.

dotnet.microsoft.com

csStudy07 project folder하위에 ControlSDK이름의 새로운 folder를 만들고 해당 folder안에서 terminal을 열어 아래 명령을 내려줍니다.

dotnet --list-sdks

만약 .NET SDK 6.0을 설치했다면 아마도 아래와 같은 결과를 표시할 수 있습니다.

6.0.418 [C:\Program Files\dotnet\sdk]
8.0.101 [C:\Program Files\dotnet\sdk]

이 상태에서 아래의 명령을 내려 global.json이름의 file을 만들고 아래와 같이 설정하여 설치한 .NET Core 6.0 SDK의 사용을 강제하도록 합니다.

dotnet new globaljson --sdk-version 6.0.410

생성된 file을 열어보면 아마도 다음과 같이 저장되어 있을 것입니다.

{
  "sdk": {
    "version": "6.0.410"
  }
}

이제 아래 명령을 통해 class library project의 생성을 시도합니다.

dotnet new classlib

만약 정상적으로 처리된다면 해당 project가 생성되어 있을 테지만 .NET SDK 6.0이 설치되지 않은 상태라면 다음의 오류가 표시될 것입니다.

The command could not be loaded, possibly because:
  * You intended to execute a .NET application:
      The application 'new' does not exist.
  * You intended to execute a .NET SDK command:
      A compatible .NET SDK was not found.

Requested SDK version: 6.0.410

(12) SDK와 framework의 혼합사용

대개의 경우 신규 project를 생성할때 Microsoft의 장기적(3년)지원을 받기 위해 long-term version의 .NET을 사용할 것입니다. 이후에 새로운 .NET version이 나오고 거기에 맞춰 upgrade할 수도 있겠지만 그렇게 하지 않는다고 해서 사용중인 .NET runtime의 생명주기동안 C#언어의 개선된 기능이나 성능에 대한 이점을 포기할 필요는 없습니다.

향후에도 C# compiler를 설치하고 사용하면서 기존 .NET에 대한 사용을 지속할 수 있습니다. 이걸 시기적으로 보면 다음과 같이 설명할 수 있습니다.

2023년 11월	.NET SDK 8.0을 설치하고 이를 사용해 .NET 8로 target이 설정된 project를 build합니다. 이때 C# 12가 기본적으로 사용됩니다. 이후에는 매달 개발자 computer에서 .NET 8 SDK와 사용자 computer상에서 .NET 8 runtime update patch가 이루어집니다.
2024년 2월	새로운 C# 언어와 .NET library기능을 확인해 보기 위해 선택적으로 .NET SDK 9 Preview를 설치할 수 있습니다. .NET 8로 target이 맞춰진 경우에는 새로운 library기능은 사용할 수 없습니다. Preview는 매년 2월 ~ 10월 사이에 release되며 공식 blog의 공지사항을 통해 Preview에서의 새로운 기능을 확인할 수 있습니다.
2024년 11월	.NET SDK 9.0.x를 설치하고 이를 사용해 .NET 8로 target이 설정된 project를 build합니다. 이때 C# 13이 기본적으로 사용되며 언어의 새로운 기능역시 사용할 수 있습니다. 또한 SDK와 runtime에 대한 완전한 지원을 받을 수 있고 .NET 8 target project에서도 EF Core 9의 새로운 기능을 사용할 수 있습니다.
2025년 2월	새로운 C# 언어와 .NET library기능을 확인해 보기 위해 선택적으로 .NET SDK 10 Preview를 설치할 수 있습니다. 만약 .NET 8 project를 새로운 version으로 전환해야 한다면 .NET9와 .NET10의 새로운 library및 ASP.NET Core 기능을 적용할 수 있는지에 대한 계획을 세워야 합니다.
2025년 11월	.NET SDK 10.0.x를 설치하고 이를 사용해 .NET 8로 target이 설정된 project를 build합니다. 이때 C# 14이 기본적으로 사용되며 언어의 새로운 기능역시 사용할 수 있습니다. 다만 .NET 8은 LTS이므로 .NET 8의 수명주기종료가 되는 2026년 11월까지 .NET 10으로의 전환이 필요합니다.

.NET SDK를 설치할때는 모든 .NET project를 build하기 위해 기본적으로 가장 최신의 version이 사용됨을 기억하시기 바랍니다. 따라서 만약 현 시점에서 .NET 9 SDK preview가 설치되면 인위적으로 사용할 version을 강제하지 않는 이상 project build를 위해 해당 version이 사용될 것입니다.

3. 배포를 위한 code 게시하기

만약 소설과 같은 글을 쓴 경우라면 이것을 다른 사람이 읽도록 하기 위해서는 '출판'해야 할 것입니다. 대부분의 개발자는 자신의 project에서 사용하거나 또는 app을 실행하는 일반사용자를 위한 code를 작성합니다. 그렇게 하기 위해서는 class library를 packaging 하거나 실행 가능한 형태의 application으로 게시를 해야 합니다.

.NET application을 배포하고 게시하기 위해서는 아래 3가지 방법을 사용할 수 있습니다.

Framework-dependent deployment (FDD)
Framework-dependent executable (FDE)
Self-contained

만약 application 및 여기에 해당하는 package종속성을 같이 배포하기로 했지만 .NET자체는 제외한다면 대상 computer에 설치된 .NET에 의존해야 합니다. 이것은 server에 web application을 배포하기에 적합한 방식입니다. 왜냐하면 .NET은 물론 다른 web application 이미 server에 존재할 수 있기 때문입니다.

Framework-dependent deployment (FDD)는 dotnet 명령줄 도구를 통해 실행될 수 있는 DLL을 배포하는 경우를 의미하며 Framework-dependent executables (FDE)는 직접적으로 실행될 수 있는 EXE를 배포하는 경우를 의미합니다. 이 둘은 모두 system에 적절한 version의 .NET runtime이 설치되어 있어야 합니다.

때로는 다른 사람에게 USB memory를 통해 application을 전달하고자 할 수 있습니다. 이런 경우 전달받은 사용자의 computer에서 실행될 수 있도록 self-contained deployment를 수행할 수 있습니다. 물론 이렇게 하는 경우 배포 file의 size가 커질 수 있지만 관련된 모든 library를 포함하게 되므로 실행하는 데는 아무런 문제가 없을 것입니다.

(1) 게시를 위한 console app 만들기

csStudy07 solution에서 DotNetEverywhere이름의 Console App project를 생성합니다. 그리고 Program.cs에서 기존 구문을 모두 삭제하고 console app이 어디서든 작동할 수 있음을 말하는 message와 현재 운영체제에 대한 정보를 출력하는 문을 아래와 같이 추가합니다.

Console.WriteLine("I can run everywhere!");
Console.WriteLine($"OS Version is {Environment.OSVersion}.");

if (OperatingSystem.IsMacOS())
{
    Console.WriteLine("I am macOS.");
}
else if (OperatingSystem.IsWindowsVersionAtLeast(major: 10, build: 22000))
{
    Console.WriteLine("I am Windows 11.");
}
else if (OperatingSystem.IsWindowsVersionAtLeast(major: 10))
{
    Console.WriteLine("I am Windows 10.");
}
else
{
    Console.WriteLine("I am some other mysterious OS.");
}

Console.WriteLine("Press ENTER to stop me.");
Console.ReadLine();

위 예제를 실행하면 다음과 같은 결과를 표시할 것입니다.(실행되는 환경에 따라 약간씩 다를 수 있습니다.)

Project file(csproj)을 열어 <PropertyGroup> 요소 안에 세 가지 운영체제를 대상으로 하기 위한 runtime 식별자를 아래와 같이 추가합니다.

<Nullable>enable</Nullable>
<RuntimeIdentifiers>
	win10-x64;osx-x64;osx.11.0-arm64;linux-x64;linux-arm64
</RuntimeIdentifiers>

추가한 요소는 다음과 같은 의미를 가집니다.

win10-x64 : Windows 10 또는 Windows Server 2016 64-bit를 의미합니다. 만약 Microsoft Surface Pro X, Surface Pro 9(SQ 3) 또는 Windows Dev Kit 2023으로 배포하고자 한다면 win10-arm64로 설정할 수 있습니다.
osx-64 : macOS Sierra 10.12이상을 의미합니다. 또한 osx.10.15-x64 (Catalina), osx.13.0-x64 (Ventura on Intel), osx.13.0-arm64 (Ventura on Apple Silicon)등 특정 version을 명시할 수도 있습니다.
linux-x64 : Ubuntu, CentOS, Debian, Fedora와 같은 Linux의 대부분의 desktop 배포판을 의미합니다. linux-arm을 사용하는 경우에는 Raspbian 또는 Raspberry Pi OS 32-bit를 의미하며 linux-arm64라면 Raspberry Pi running Ubuntu 64-bit를 의미합니다.

특정 runtime을 식별하기 위해 사용가능한 2가지 요소가 있습니다. <RuntimeIdentifier>는 특정한 한 가지만을 지정해야 하는 경우에 사용하며 <RuntimeIdentifiers>는 예제와 같이 여러 가지를 지정해야 하는 경우에 사용합니다. 그런데 만약 잘못된 값을 사용하게 된다면 compiler는 error를 발생시키게 되는데 경우에 따라 단 하나의 잘못된 문자로 error가 발생하는 경우에 무엇이 잘못되었는지 찾기가 어려워질 수 있으므로 주의해야 합니다.

(2) dotnet 명령

.NET SDK를 설치하게 되면 dotnet이라는 이름의 command line interface(CLI)를 같이 설치하게 됩니다.

● 새로운 project 생성

.NET CLI는 template을 사용해 새로운 project를 현재 folder에 생성하는 명령을 포함하고 있습니다.

Terminal을 열고 .NET 7이상 이라면 'dotnet new list'를, .NET 6라면 'dotnet new --list'혹은 'dotnet new -l'명령을 내려줍니다. 그러면 다음과 같이 현재 설치된 template을 표시하게 됩니다.

대부분의 dotnet 명령의 switche는 길고 짧은 version을 각각 사용할 수 있기 때문에 만약 --list라 하면 -l처럼 사용할 수 있습니다. 짧은 것은 typing 하기에 빠를 수 있지만 다른 사람이나 심지어 본인도 잘못 명령을 해설할 수 있으므로 긴 것을 사용하면 의미를 좀 더 명확히 전달할 수 있습니다.

.NET MAUI는 Linux를 지원하지 않습니다. 해당 작업은 open source community에서 계속 진행되겠지만 진정한 cross-platform UI를 사용해야 한다면 Avalonia를 참고하시기 바랍니다.

Avalonia UI - Home

Avalonia UI - Cross-Platform UI Framework for .NET

Pixel-Perfect Cross-Platform .NET Applications with C# for Windows, macOS, Linux, iOS, Android and Browser.

www.avaloniaui.net

(3) .NET및 실행환경에 대한 정보 파악하기

현재 설치된 .NET SDK및 runtime과 함께 운영체제에 대한 정보를 확인해 보려면 'dotnet --info'명령을 사용하면 됩니다.

(4) dotnet CLI로 Project 관리하기

.NET CLI는 아래명령을 통해 project를 관리하기 위해 현재 folder에 project에 대한 몇 가지 작업을 수행할 수 있습니다.

dotnet help : dotnet 명령에 대한 도움말을 표시합니다.
dotnet new : 새로운 .NET project 또는 file을 생성합니다.
dotnet tool : .NET 환경을 확장하기 위한 도구를 설치하거나 관리합니다.
dotnet workload : .NET MAUI와 같은 선택적 workload를 관리합니다.
donet restore : project에 대한 의존성을 download 합니다.
dotnet build : .NET Project를 build(compile)합니다. .NET 8에서는 --tl라는 새로운 option을 추가했으며 이를 통해 build가 수행중인 작업에 대한 실시간 정보를 확인할 수 있습니다. 좀더 자세한 사항은 dotnet build command - .NET CLI | Microsoft Learn 이곳을 참고하시기 바랍니다.
dotnet build-server : build에 의해 시작된 server와의 상호작용을 수행합니다.
dotnet msbuild : MS Build Engine명령을 실행합니다.
dotnet clean : build로 생성되는 임시 folder를 삭제합니다.
dotnet test : project에 대한 단위 test를 build 하고 실행합니다.
dotnet run : project를 build하고 실행합니다.
dotnet pack : project에 대한 NuGet package를 생성합니다.
dotnet publish : 의존성 또는 self-contained application과 함께 project를 build하고 게시합니다. .NET 7및 그 이전 version에서는 배포시 Debug의 설정이 기본이었으나 .NET 8부터는 Release설정이 기본으로 게시합니다.
dotnet add : project에 package 혹은 class library에 대한 참조를 추가합니다.
dotnet remove : project에 대한 package 혹은 class library 참조를 삭제합니다.
dotnet list : project에 참조된 package 또는 class library를 listing 합니다.

(5) Self-contained app 게시하기

위에서 만든 cross-platform console app인 DotNetEverywhere를 게시하려면 terminal에서 DotNetEverywhere project가 있는(csproj가 있는) folder로 이동한 뒤 다음과 같은 명령을 내려 project를 build 하고 self-contained release version으로 Windows 10에서의 console application을 게시하도록 합니다.

dotnet publish -c Release -r win10-x64 --self-contained

이렇게 하면 build engine은 필요한 모든 package를 복구하고 project source code를 assembly DLL로 compile 하여 publish folder를 만들어 저장하게 됩니다.

Determining projects to restore...
All projects are up-to-date for restore.
DotNetEverywhere -> C:\Users\w10tsp\DotNetEverywhere\bin\Release\net7.0\win10-x64\DotNetEverywhere.dll
DotNetEverywhere -> C:\Users\w10tsp\DotNetEverywhere\bin\Release\net7.0\win10-x64\publish\

이어서 아래 명령을 추가로 사용해 macOS와 다양한 Linux에서의 release version으로 게시하도록 합니다.

dotnet publish -c Release -r osx-x64 --self-contained
dotnet publish -c Release -r osx.11.0-arm64 --self-contained
dotnet publish -c Release -r linux-x64 --self-contained
dotnet publish -c Release -r linux-arm64 --self-contained

필요하다면 위와 같은 명령들은 PowerShell과 같은 script 언어를 사용해 자동화하고 cross-platform인 PowerSheel Core를 사용해 모든 OS상에서 script file을 실행할 수 있습니다. 이는 그저 위의 명령들을 저장한 .ps1 확장자 file을 만들고 file을 실행하기만 하면 됩니다. PowerShell에 관해서는 아래 link를 통해 더 자세한 정보를 확인하실 수 있습니다.

cs11dotnet7/docs/powershell at main · markjprice/cs11dotnet7 · GitHub

GitHub - markjprice/cs11dotnet7: Repository for the Packt Publishing book titled "C# 11 and .NET 7 - Modern Cross-Platform Devel

Repository for the Packt Publishing book titled "C# 11 and .NET 7 - Modern Cross-Platform Development Fundamentals" by Mark J. Price - GitHub - markjprice/cs11dotnet7: Repository for the ...

github.com

위 명령을 실행한 뒤 Windows 탐색기를 열어 'DotNetEverywhere\bin\ Release\net7.0' folder로 이동해 보면 다섯 가지 OS에 대한 output folder가 생성되어 있음을 확인하실 수 있습니다.

'win10-x64' folder안에서 publish folder를 선택해 보면 Microsoft.CSharp.dll과 같은 필요한 모든 assembly가 저장되어 있음을 볼 수 있으며 이중 DotNetEverywhere.exe file을 선택하면 대략 file의 크기가 151 KB정도 됨을 보실 수 있습니다.

현재 OS가 Windows라면 해당 file을 double click 하여 program을 실행하고 그 결과를 확인해 볼 수 있습니다.

I can run everywhere!
OS Version is Microsoft Windows NT 10.0.19045.0.
I am Windows 10.
Press ENTER to stop me.

참고로 publish folder의 전체 크기는 대략 70MB 정도 됩니다. 각 OS별로 만들어진 publish folder를 필요한 OS에 복사하고 실행하면 아마도 정상적으로 실행됨을 알 수 있을 것입니다. 이는 console app이 .NET application에 대한 self-contained 배포판이기 때문입니다.

예제에서는 console app을 사용했지만 ASP.NET Core website나 web service 또는 Windows Forms나 WPF app과 같은 것들도 쉽게 만들 수 있습니다. 물론 이때도 Linux나 macOS가 아닌 Windows computer를 위한 Windows desktop app을 배포할 수도 있습니다.

(6) 단일 file app 게시하기

단일 file로서 게시하고자 한다면 게시할 때 flag를 지정할 수 있습니다. .NET 5에서 단일 file app은 Windows와 macOS에서 사실상 기술적으로 단일 file 배포가 불가능했기 때문에 주로 Linux에 집중되었습니다. 그러나 .NET 6 이후에부터는 Windows에서도 적절한 단일 file app을 만들 수 있게 되었습니다.

만약 app을 실행하고자 하는 computer에 적절한 version의 .NET이 설치되어 있다면 app을 게시할 때 아래와 같이 확장 flag를 사용해 self-contained가 필요하지 않고 단일 file로서 배포(가능하다면)하고자 함을 알려줄 수 있습니다.

dotnet publish -r win10-x64 -c Release --no-self-contained /p:PublishSingleFile=true

위와 같이 하면 2개의 file이 생성되는데 하나는 exe, 다른 하나는 pdb입니다. exe는 실행가능한 file을 의미하며 pdb는 program debug database로서 debugging에 필요한 정보를 담고 있습니다.

macOS상에서 게시된 application애 대한 exe는 존재하지 않으므로 osx-x64와 같은 명령을 사용해야 하며 생성된 file에는 확장자가 존재하지 않을 것입니다.

만약 pdb file마저도 exe안으로 포함시키고자 한다면 assembly와 함께 배포되도록 해야 하며 그러기 위해서 csproj file에서 <PropertyGroup> 요소 안에 <DebugType> 요소를 추가하고 여기에 embedded를 아래와 같이 설정합니다.

<RuntimeIdentifiers>
	win10-x64;osx-x64;osx.11.0-arm64;linux-x64;linux-arm64
</RuntimeIdentifiers>
<DebugType>embedded</DebugType>

그러나 대상 computer에 .NET이 설치되어 있지 않은 상태라면 Linux의 경우 단 2개의 file만을 필요로 하지만 Windows라면 coreclr.dll, clrjit.dll, clrcompression.dll 그리고 mscordaccore.dll과 같은 추가적인 file이 필요합니다.

terminal에서 아래 명령을 통해 Windows 10용 console app의 self-contained release version을 build 합니다.

dotnet publish -c Release -r win10-x64 --self-contained /p:PublishSingleFile=true

그리고 DotNetEverywhere\bin\Release\net7.0\win10-x64\publish foler에서 DotNetEverywhere.exe file을 선택합니다. 그러면 해당 file의 크기가 거의 65MB 정도로 커지게 되는 것을 알 수 있습니다. 또한 pdb file은 11KB 정도인데 이는 system에 따라 크기가 달라질 수 있습니다.

(7) App trimming을 사용한 app size 줄이기

.NET app을 self-contained app으로 배포하는 데 있어서 한 가지 문제점은 .NET library에서 너무 많은 용량을 차지한다는 것이며 특히 문제는 모든 .NET Library를 brwoser에서 내려받아야 하는 Blazor WebAssembly component가 문제가 될 수 있고 이러한 여러 가지 이유로 size를 줄여줄 필요가 있습니다.

그리고 이러한 문제는 배포 시 사용하지 않는 assembly를 packaging에서 제외하도록 함으로써 해결할 수 있습니다. .NET Core 3.0에서 도입된 app trimming system은 code에서 필요한 assembly를 식별하고 필요하지 않은 것들을 제거할 수 있습니다. 이를 copyused trim mode라고 합니다.

.NET 5에서 trimming은 개별 type을 제거하고 심지어 assembly안에서 사용되지 않는 method등의 member를 제거할 수도 있습니다. template에 의해 생성된 기본 console app의 경우 trimming된 System.Console.dll assembly는 대략 60KB에서 30KB로 줄어드는데 .NET 5에서 당시 이 기능은 실험적인 기능이라 기본적으로 사용되지 않도록 disable되어 있습니다.

.NET 6에서 Microsoft는 자신들의 library에 주석을 추가하여 어떤 식으로 안전하게 trimming 할 수 있는지를 나타내도록 하였으며 이에 따라 type과 member의 trimming이 기본적으로 사용되도록 적용되었고 이를 link trim mode라고 합니다.

.NET 7에서 Microsoft는 link를 full로 copyused를 partial로 명칭을 변경하였습니다.

문제는 trimming이 사용되지 않는 assembly, type, member 등을 얼마나 잘 식별하느냐 하는 것입니다. 만약 code가 동적인 것, 예를 들어 reflection과 같은 것이라면 정확하게 작동하지 않을 수 있고 이것 때문에 Microsoft는 수동적인 조정이 가능하도록 하였습니다.

● Assembly 수준 trimming 사용

Assembly 수준의 trimming을 사용하는 데는 2가지 방법이 있습니다. 첫 번째는 csproj(project file)에 아래와 같은 요소를 추가하는 것입니다.

<PublishTrimmed>true</PublishTrimmed>

두 번째는 게시할 때 아래와 같이 flag를 사용하는 것입니다.

dotnet publish -c Release -r win10-x64 --self-contained -p:PublishTrimmed=True

● Type 및 member수준의 trimming 사용

여기에도 2가지 방법이 있는데 첫 번째는 위의 예와 마찬가지로 아래의 요소를 추가하는 것이며

<PublishTrimmed>true</PublishTrimmed>
<TrimMode>Link</TrimMode>

두 번째 방법으로 flag를 사용하는 것입니다.

dotnet publish ... -p:PublishTrimmed=True -p:TrimMode=Link

.NET 6에서 link trim mode는 기본적으로 사용할 수 있으므로 assembly수준의 trimming을 의미하는 copyuse와 같은 다른 trim mode를 사용하고자 하는 경우일 때만 swich를 지정하면 됩니다.

(8) build artifact가 생성되는 위치 조정하기

일반적으로 각 project는 자신만의 obj와 bin folder를 가지고 있어서 여기에 build 동안의 임시 file이 생성되며 특히 bin은 배포를 위한 file이 생성됩니다. .NET 8에서는 필요하다면 obj와 bin에 생성되는 file의 위치를 변경할 수도 있는 기능을 도입하였습니다.

project가 존재하는(*.csproj file이 존재하는) folder에서 아래와 같이 명령을 내려줍니다.

dotnet new buildprops --use-artifacts

그러면 특별한 경우가 아닌한 다음과 같이 message가 표시되며

해당 folder에는 'Directory.Build.props'이름의 file이 표시됩니다. file은 다음과 같은 makeup으로 저장되어 있습니다.

<Project>
  <!-- See https://aka.ms/dotnet/msbuild/customize for more details on customizing your build -->
  <PropertyGroup>

    <ArtifactsPath>$(MSBuildThisFileDirectory)artifacts</ArtifactsPath>

  </PropertyGroup>
</Project>

위의 설정은 build process가 시작되면 그에 따른 folder가 artifacts 이름의 folder안에 생성됨을 의미합니다. 따라서 project를 build해 보면

bin과 obj folder가 위와 같이 생성되어 있음을 확인할 수 있습니다.

(9) Native ahead-of-time compilation

Native AOT는 .NET이 설치되어 있지 않은 환경에서의 실행을 위해 Self-contained 형태로 assembly를 생성하고 그것을 native code로 compile하여 더 빠르게 실행하고 더 적은 memory를 사용할 수 있도록 합니다.

즉, runtime에서 JIT(Just In Time) compiler를 사용하는 대신 배포시점에 IL code를 native code로 compile하는 것인데 위에서 설명한 이점을 얻을 수 있는 대신 Windows x64나 Linux Arm과 같이 특정한 runtime환경이 지정되어야 합니다.

native AOT는 게시시점에 발생하므로 현재 project가 AOT를 사용하도록 설정되어 있다고 하더라도 debugging의 목적으로 실행하는등의 동작시에는 여전히 native AOT가 아닌 runtime JIT compiler를 사용하게 됩니다.

다만 native AOT와 호환되지 않는 일부 기능은 disable되거나 예외를 발생시킬 수 있으며 source 분석기가 활성화되어 잠재적인 code 비호환성에 대한 경고를 표시하게 됩니다.

● Native AOT 의 한계

Native AOT는 다음과 같은 일부 한계가 존재합니다.

Assembly의 동적 loading이 없습니다.
System.Reflection.Emit을 사용하는 것과 같은 runtime code 생성이 없습니다.
Trimming이 필요하며 여기에는 자체적인 한계가 존재합니다.
필요한 모든 library를 포함하는 Self-contained으로만 배포되므로 배포크기가 커질 수 있습니다.

물론 자체 assembly에서 위의 기능을 사용하지 않을 수 있지만 .NET 자체의 주요부분은 해당 기능을 사용합니다. 예를 들어 ASP.NET Core MVC(Controller를 사용하는 Web API service를 포함해)와 EF Core는 자신들의 기능을 구현하기 위해 runtime code 생성을 수행합니다.

.NET Team은 native AOT와 .NET과의 더 나은 호환성을 위해 노력중이지만 Minimal API를 사용하는 경우에만 .NET 8에서 ASP.NET Core에 대한 기본적인 지원을 포함하고 있으며 EF Core는 지원하지 않습니다.

Native AOT 게시 process는 지원하지 않는 기능을 사용하는 경우 이를 알려주기 위한 code 분석기를 포함하고 있지만 아직까지 모든 package가 이러한 기능이 잘 작동하도록 anotate되어 있지는 않습니다. Type또는 member가 AOT를 지원하지 않음을 나타내는데 사용된 가장 일반적인 annotation은 [RequiresDynamicCode] attribute입니다.

AOT가 나타내는 위험성에 관한 자세한 사항은 아래 link를 참고하시가 바랍니다.

Introduction to AOT warnings - .NET | Microsoft Learn

Introduction to AOT warnings - .NET

Learn why warnings might be produced when publishing an application as Native AOT, how to address them, and how to make the application "AOT compatible."

learn.microsoft.com

● Reflection 과 native AOT

Reflection는 runtime에서 type의 metadata를 검사하고 member의 동적호출과 code생성을 목적으로 자주사용됩니다.

Native AOT는 일부 reflection기능을 허용하긴 하지만 native AOT compilation process동안 수행되는 trimming은 type이 reflection을 통해서만 접근가능한 member를 가지고 있는지의 여부를 정적으로 판단할 수 없고 따라서 이들 member는 AOT에 의해 제거될 수 있고 때문에 runtime예외를 일으킬 수 있습니다.

개발자는 자신의 type에 [DynamicallyAccessedMembers]으로 annotate함으로서 해당 member가 reflection을 통해서만 접근될 수 있고 때문에 trimming하지 않은 상태로 남아있어야 함을 표시할 수 있습니다.

● Native AOT의 요구사항

Native AOT는 운영체제에 따라 다음과 같은 추가적인 요구사항이 뒤따릅니다.

Windows	전체 기본 component를 가진 Visual Studio 2022 Desktop development with C++ workload 설치
Linux	compiler toolchain과 .NET runtime이 의존하는 library를 위해 developer package를 설치해야 합니다. 예를 들어 Ubuntu 18.04 이상에서 다음과 같은 명령을 내려줍니다. sudo apt-get install clang zlib1g-dev

Cross-platform native AOT 배포는 지원하지 않습니다. 즉, 배포하고자 하는 특정 운영제제상에서 배포되어야 합니다. 때문에 Linux에서의 native AOT project 배포본은 Windows상에서 실행될 수 없습니다. 물론 그 반대도 마찬가지 입니다.

● Project에 native AOT 적용하기

Project에서 native AOT 배포를 적용하려면 project (csproj) file에 다음과 같이 <PublishAot>요소를 추가해야 합니다.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <PublishAot>true</PublishAot>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

● Native AOT project build 하기

Visual Studio를 통해 native AOT 호환 project를 생성하려면 다음과 같이 'Enable native AOT publish'를 check합니다.

dotnet CLI를 통해서는 다음과 같이 --aot option을 통해 project를 생성할 수 있습니다.

dotnet new console --aot

위의 방법으로 생성된 project file에서는 PublishAot와 InvariantGlobalization요소가 추가됩니다.

<PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFramework>net8.0</TargetFramework>
  <ImplicitUsings>enable</ImplicitUsings>
  <Nullable>enable</Nullable>
  <PublishAot>true</PublishAot>
  <InvariantGlobalization>true</InvariantGlobalization>
</PropertyGroup>

.NET 8의 Console App project에서는 명시적으로 invariant globalization를 true로 설정하는 것은 새로운 기능으로 이는 app이 특정한 문화권에 구애받지 않고 전세계 어디서든 배포되고 동일한 동작을 수행하도록 합니다. 만약 이 요소의 설정을 false로 하거나 요소자체를 누락한다면 현재 computer의 문화권을 기본으로 설정하게 됩니다. 이에 관한 좀더 자세한 사항은 아래 link를 참고하시기 바랍니다.

runtime/docs/design/features/globalization-invariant-mode.md at main · dotnet/runtime · GitHub

이어 program.cs에서는 기존의 문을 모두 삭제하고 현재 문화권과 OS version을 표시하도록 수정합니다.

using System.Globalization;

Console.WriteLine("현재 문화권 설정: {0}", CultureInfo.CurrentCulture. DisplayName);
Console.WriteLine("운영체제: {0}", Environment.OSVersion);

Console.Write("종료하려면 아무키나 누르십시오...");
Console.ReadKey(intercept: true);

project를 실행하고 결과를 확인합니다.

하지만 native AOT는 배포시점에 적용되므로 build된 실행 file은 여전히 JIT compiler를 사용합니다.

● Native AOT project 배포하기

개발중에 정상적으로 작동하는 console app이라도 trimming하지 않고 JIT compile하게 되면 이를 native AOT를 사용해 배포하는 것은 실패할 수 있습니다. 일단 trimming이 이루어지고 JIT compile되어야 native AOT 배포를 사용할 수 있는 상태가 됩니다.

배포동안에 project가 AOT에 관한 어떠한 경고도 표시하지 않는다면 해당 app은 AOT 배포후에 잘 작동하리라고 기대할 수 있습니다.

project를 배포하려면 다음과 같이 명령을 내려줍니다.

배포실행 후 'bin\Release\net8.0\win-x64\publish' folder를 보면 실행 file이 1.2M가 넘는것을 확인할 수 있습니다. 참고로 pdb file은 debuging에 사용되는 file입니다. 여기에 있는 해당 exe file을 실행하면 이전과 정확히 같은 동작을 수행한다는 것을 확인할 수 있습니다.

다시 program.cs로 돌아와 이번에는 동적 code를 위한 namespaces를 아래와 같이 추가합니다.

using System.Reflection; // To AssemblyName.
using System.Reflection.Emit; // To AssemblyBuilder.

using System.Globalization;

그리고 동적 assembly builder를 생성하도록 아래와 같이 code를 추가하고

AssemblyBuilder ab = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("assemblyName"), AssemblyBuilderAccess.Run);

Console.WriteLine("현재 문화권 설정: {0}", CultureInfo.CurrentCulture. DisplayName);

다시 배포를 시도하면 아래와 같은 경고 message를 보게 됩니다.

대략적인 내용은 .NET team 이 [RequiresDynamicCode] attribute를 적용한 DefineDynamicAssembly method의 호출에 관한 것입니다.

native AOT에 관한것은 아래 linki에서 좀더 자세하게 알아보실 수 있습니다.

Native AOT deployment overview - .NET | Microsoft Learn

Native AOT deployment overview - .NET

Learn what Native AOT deployments are and why you should consider using it as part of the publishing your app with .NET 7 and later.

learn.microsoft.com

4. .NET assembly decompile

C#을 학습하기 위한 가장 좋은 방법 중에 하나는 수준 높은 다른 누군가가 만들어 놓은 code를 보는 것입니다.

물론 학습목적이 아닌 자신의 library나 application에 사용할 목적으로 code를 복사하기 위한 decompile을 시도해 볼 수도 있을 것입니다. 어쨌건 decompile은 그들의 지적재산권을 침해하는 것으로 귀결될 수 있으므로 주의해야 합니다.

(1) Visual Studio 2022의 ILSpy extension을 사용한 decompile

.NET assembly의 decompile은 ILSpy와 같은 도구를 통해 가능합니다. Visual Studio에서 Extensions -> Manage Extensions menu를 선택합니다.

왼쪽 category에서 online을 선택하고 search에 'ILSpy'를 입력하고 ILSpy 2022 선택한 뒤 download button을 눌러줍니다.

Download가 완료되면 Visual Studio를 닫아 내려받은 ILSpy 2022의 설치를 완료합니다.

Visual Studio를 재시작하고 csStudy07 project를 열어줍니다. 그리고 solution explorer에서 DotNetEverywhere project를 mouse오른쪽 click한뒤 'Open output in ILSpy'를 선택합니다.

잠시가다리면 ILSpy가 열리게 되는데 decompile 할 언어설정이 C#으로 되어 있는지 확인합니다. 왼쪽 화면에는 'Assemblies navigation'화면이 보이는데 여기에서 DotNetEverywhere를 확장합니다. 이어서 '{ }'와 Program을 차례로 확장한 뒤 '<Main>$(string[]) : void'부분을 click 하여 compiler가 생성한 Program class와 보간문자열이 어떻게 작동하는지를 나타내는 <Main>$ method를 표시합니다.

계속해서 ILSpy에서 File -> Open menu를 선택한 뒤 'DotNetEverywhere/bin/Release/net7.0/linux-x64' foler에서 System.Linq.dll file을 열어봅니다. 그리고 Assemblies tree에서 'System.Linq ~'와 System.Linq namespace, Enumerable class를 차례로 확장한 뒤 'Count<TSource>(this IEnumerable<TSource>) : int'를 선택합니다.

Count method를 보면 몇 가지 배워볼 만한 점을 발견할 수 있습니다.

source 매개변수를 확인하고 null이라면 ArgumentNullException 예외를 발생시키도록 합니다.
source는 좀 더 효휼적으로 읽어 들일 수 있는 자체의 Count속성으로 구현할 수 있는 Interface를 확인합니다.
source의 모든 item을 열거하고 counter를 증가시키는 마지막 method는 구현 효율성이 가장 낮습니다.

Count method의 source code를 확인하고

public static int Count<TSource>(this IEnumerable<TSource> source)
{
	if (source == null)
	{
		ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
	}
	if (source is ICollection<TSource> collection)
	{
		return collection.Count;
	}
	if (source is IIListProvider<TSource> iIListProvider)
	{
		return iIListProvider.GetCount(onlyIfCheap: false);
	}
	if (source is ICollection collection2)
	{
		return collection2.Count;
	}
	int num = 0;
	using IEnumerator<TSource> enumerator = source.GetEnumerator();
	while (enumerator.MoveNext())
	{
		num = checked(num + 1);
	}
	return num;
}

그다음 Intermediate Language (IL)에서 생성한 것과 동일한 code를 비교해 보기 위해 toolbar에서 C#에 대한 dropdownlist를 ILSpy로 변경합니다.

C# compiler가 source code를 IL code로 변환시킨다는 것만 알고 있으면 될 뿐 사실 IL code가 딱히 유용하지는 않습니다. 위의 source code만 가지고도 Count method가 인수에 대해 어떻게 null을 확인하는지 등을 알 수 있으므로 훨씬 유용하게 활용될 수 있습니다.

아래 link에서는 Visual Studio에서 ILSpy를 어떻게 사용할 수 있는지를 확인할 수 있습니다.

cs11dotnet7/docs/code-editors/vscode.md at main · markjprice/cs11dotnet7 · GitHub

GitHub - markjprice/cs11dotnet7: Repository for the Packt Publishing book titled "C# 11 and .NET 7 - Modern Cross-Platform Devel

Repository for the Packt Publishing book titled "C# 11 and .NET 7 - Modern Cross-Platform Development Fundamentals" by Mark J. Price - GitHub - markjprice/cs11dotnet7: Repository for the ...

github.com

(2) Visual Studio 2022를 통한 source link 보기

Decompile대신 Visual Studio에는 source link를 사용해 본래 source code를 볼 수 있는 기능을 가지고 있습니다.

csStudy07 solution에서 'SourceLinks'라는 Console app유형의 새로운 project를 생성하고 Program.cs에서 string변수를 선언하고 해당 변수가 가진 문자열의 수를 다른 변수에 할당하고 확인하는 문을 아래와 같이 추가합니다.

string name = "cliel";
int length = name.Count();

Console.WriteLine($"{name} has {length} characters.");

이때 Count method에서 mouse오른쪽 button을 click 하여 'Go To Implementation'을 선택합니다. 그러면 Count.cs이름의 source code file이 표시될 텐데 여기서 우리는 count와 관련된 다섯 개의 method가 Enumerable이라는 partial class에 구현되어 있음을 알 수 있습니다.

이러한 source links를 통해서도 위 예제와 같이 관리의 용이성을 위해 어떻게 partial class를 통해서 class를 나누는지와 같은 상황별 예시를 확인할 수 있기 때문에 decompile 하는 것만큼 많은 것을 배울 수 있습니다. ILSpy를 사용하는 경우에도 물론 Enumerable class에 대한 수천 개의 method를 모두 볼 수 있습니다.

아래 link를 통해서는 source links에 관한 더 많은 것과 얼마나 많은 NuGet package가 이를 지원할 수 있는지를 확인해 볼 수 있습니다.

Source Link and .NET libraries | Microsoft Learn

Source Link and .NET libraries

Best practice recommendations for using Source Link to improve debugging for .NET libraries.

learn.microsoft.com

만약 source link가 작동하지 않으면 아래 설정에서 source link의 설정여부를 확인해 보시기 바랍니다.

(3) 기술적으로 decompile을 막을 수 있는 방법은 없습니다.

누군가는 compile 된 code에서 decompile을 막을 수는 없을까 하는 의문을 제기할 수도 있을 것입니다. 이 질문에 정확하게 답하자면 '그렇게 할 수 없다.'라고 할 수 있습니다. 대신 Dotfuscator와 같은 도구를 사용해 code를 읽기 어렵게 만들 수는 있지만 decompile자체는 막을 수 없습니다.

모든 compile 된 application은 동작의 대상이 되는 platform, OS 그리고 hardware에 대한 명령을 포함하고 있습니다. 이들 명령은 기능적으로 본래 source code와 일치하지만 사람에게만 읽기 어렵게 만들수 있을 뿐입니다.

Source code를 보호하고자 한다면 여기에 debugger을 연결하고 단계적으로 code를 통과하는 것도 막을 수 있습니다. compile된 application이 pdb file을 가지고 있다면 debugger를 연결하고 구문을 한 줄씩 실행시킬 수도 있습니다. pdb file이 없어도 여전히 debugger를 연결하고 code가 어떻게 작동하는지를 알 수 있습니다.

사실 decompile에 관한 이러한 내용은 C#, Visual Basic, F#과 같은 .NET언어 뿐만 아니라 C, C++, Delphi 및 assembly 언어(debugging에 연결하거나 disassembled 또는 decompile 될 수 있는)에도 해당하는 사실입니다. 아래 표는 해당 목적을 위해 사용하는 일부 도구를 나타내고 있습니다.

목적	도구	설명
Debugger	SoftICE	운영체제(일반적으로 VM) 아래에서 실행됩니다.
Debugger	WinDbg	다른 debugger보다 Windows data 구조에 관한 더 많은 것을 이해하는데 유용한 도구입니다.
Disassembler	IDA Pro	malware 분석등에 사용됩니다.
Decompiler	HexRays	IDA Pro의 plugin이며 C app을 decompile합니다.
Decompiler	DeDe	Delphi app을 decompile합니다.
Decompiler	dotPeek	JetBrains사에서 만든 것으로 .NET decompiler입니다.

다른 누군가의 software를 Debugging, disassembling, decompiling 하는 행위는 license동의에 반하며 불법일 수 있습니다. 기술적인 방법으로 지적재산권을 보호하는 대신 법이 유일단 수단이 될 수 있습니다.

5. .NET Framework 에서 .NET으로의 이식

기존 .NET Framework 개발자라면 아마도 기존의 application을 .NET으로 전환하고자 할 수 있을 것입니다. 하지만 정말 .NET으로의 전환이 가장 좋은 방법인지는 심도 있게 고려해봐야 합니다. 단지 .NET으로의 이식만이 최상의 방법이 되지는 않습니다.

예를 들어 .NET Framework 4.8에서 동작하는 사용자가 그리 많지 않은 website project가 있습니다. 그러면 해당 website는 최소한의 hardware상에서 방문자 traffic은 충분히 제어되고 작 잘 동할 수 있을 텐데 이것을 .NET platform으로 전환하는데 잠재적으로 수개월을 소요하는 것은 시간낭비가 될 수 있습니다. 하지만 website가 현재 다수의 고비용 Windows Server가 필요하다면 더 비용이 적은 Linux server로 migration 할 수 있습니다.

(1) 전환 가능한 것

.NET은 Windows, macOS, Linux에 대한 아래 type의 application을 지원하고 있으며 때문에 전환이 가능합니다.

Razor Pages와 MVC를 포함한 ASP.NET Core web site
Web API, Minimal API, OData를 포함하는 ASP.NET Core web service(REST/HTTP)
gRPC, GraphQL, SignalR을 포함하는 ASP.NET Core-hoste
명령행 interface인 Console App포함

.NET은 Windows에 대한 아래 Type의 application을 지원하고 있으며 운영에 적합이 가능합니다.

Windows Forms applications
Windows Presentation Foundation (WPF) applications

.NET은 cross-platform desktop과 mobile device에 대한 아래 type의 application을 지원하고 있으며 전환이 가능합니다.

Mobile iOS와 Android를 위한 Xamarin app
Desktop Windows와 macOS 또는 mobile iOS와 Android를 위한 .NET MAUI

.NET은 아래 legacy Microsoft project에 대한 지원을 하지 않으며 전환이 불가능합니다.

ASP.NET Web Forms website. (ASP.NET Core Razor Page 또는 Blazor로의 재구현이 필요합니다.)
Windows Communication Foundation (WCF ) service (단, 요구사항에 따라 사용가능한 open-source project인 CoreWCF가 존재합니다.). (ASP.NET Core gRPC service로의 재구현이 필요합니다.)
Silverligth application. (Blazor 또는 .NET MAUI로의 재구현이 필요합니다.)

Silverlight와 ASP.NET Web Forms application은 .NET으로의 전환이 불가능하며 기존의 Windows Forms와 WPF application을 WIndows전용의 .NET으로 전환하면 이에 따른 새로운 API와 고성능에 대한 이점을 가져갈 수 있습니다.

Legacy ASP.NET MVC web application과 ASP.NET Web API web service역시 .NET으로의 전환이 가능하며 Windows, Linux 또는 macOS에서 host가 가능합니다.

(2) 전환해야 하는 것

전환이 가능하다면 그렇게 하는 것이 맞을까? 그렇게 한다면 어떤 이익을 얻을 수 있을까? 전환함으로써 얻을 수 있는 장점으로는 대략 다음과 같이 정리할 수 있습니다.

Website와 webservice에 대한 Linux, Docker 또는 Kubernetes로의 배포 : 해당 OS들은 website와 web service platform으로서 매우 가볍고 특히 Windows Server와 비교해서는 훨씬 비용 효과적이라고 할 수 있습니다.
IIS와 System.Web.dll에 대한 의존성 제거 : Windows Server로의 배포를 계속한다고 하더라도 ASP.NET Core는 Kestrel web server(또는 다른 것도 마찬가지)에서 가벼우면서도 고성능의 hosting이 가능합니다.
명령줄 도구 : 개발자와 관리자가 자신들의 작업을 자동화하기 위해 사용하는 도구는 종종 console application으로 build 되는데 cross-platform에서 동작가능한 단일 도구는 그 자체로 매우 유용하게 사용될 수 있습니다.

(3) .NET Framework와 .NET의 차이

이들 사이에는 대략 3가지 핵심적인 차이가 존재합니다.

.NET	.NET Framework
NuGet package로 배포되어 있으며 각 application은 필요한 .NET version의 자체 app local 복사를 통해 배포될 수 있습니다.	System전반에 배포되어 있으며 assembly들은 공유됩니다.(GAC-Global Assembly Cache)
Component 계층으로 작게 나누어져 있으므로 최소한의 배포가 가능합니다.	단일적이며 획일적인 배포만이 가능합니다.
ASP.NET Web Forms와 같은 고전 기술과 AppDomains, .NET Remoting, binary serialization과 같은 비 cross-platform 기능들이 제거되었습니다.	.NET에서의 ASP.NET Core MVC와 같은 비슷한 기능뿐만 아니라 ASP.NET Web Forms와 같은 고전적인 기술까지도 남아 있습니다.

(4) .NET Portability Analyzer

Microsoft는 기존의 application에 대한 이식성의 보고서를 생성하는 유용한 도구를 지원하고 있습니다. 아래 link에서 해당 도구의 시연장면을 볼 수 있습니다.

A Brief Look at the .NET Portability Analyzer | Microsoft Learn

A Brief Look at the .NET Portability Analyzer

.NET is going through some monumental changes! It is often difficult to even begin to think about how to port our particular code to the various flavors of .NET. In this video Taylor Southwick and Connie Yau spend some time discussing a great tool that wil

learn.microsoft.com

(5) .NET Upgrade Assistant

Legacy project를 .NET으로 upgrade 하기 위한 가장 최신의 도구로는 .NET Upgrade Assistant가 있습니다. 현재 다음과 같은 .NET Framework project type을 지원하고 있으며 향후에는 더 추가될 것으로 예상됩니다.

ASP.NET MVC
Windows Forms
WPF
Console Application
Class Library

전역 dotnet 도구를 통해 .NET Upgrade Assistant를 설치하려면 아래의 명령을 내려줍니다.

dotnet tool install -g upgrade-assistant

아래 link를 통해 .NET Upgrade Assistant에 대한 더 자세한 내용과 사용법을 확인할 수 있습니다.

Overview of the .NET Upgrade Assistant - .NET Core | Microsoft Learn

Overview of the .NET Upgrade Assistant - .NET Core

Introducing the .NET Upgrade Assistant tool that helps upgrade .NET, .NET Core, or .NET Framework apps to the latest version of .NET.

learn.microsoft.com

(6) 비 .NET Standard library 사용

NuGet package는 .NET Standard 또는 .NET 7과 같은 version을 통해 compile 되지 않은 것이라 하더라도 대부분 .NET에서 사용될 수 있습니다. 만약 공식적으로 .NET Standard를 지원하지 않는 package라고 nuget.org web page에 표시된 package가 있어도 단정적으로 사용 못할 것이라 포기할 필요는 없습니다. 일단 시도해 보면서 되는지 안되는지의 여부를 판단해도 됩니다.

예를 들어 아래와 같이 문서화된 것으로, Dialect Software LLC에서 제작된 행렬처리를 위한 사용자 지정 collection package는 .NET Core나 .NET 7이 존재하기 훨씬 이전인 2013년도가 마지막 update로 확인됩니다.

NuGet Gallery | DialectSoftware.Collections.Matrix 1.0.0

DialectSoftware.Collections.Matrix 1.0.0

Provides matrix data structure suitable for storing elements in an n-dimensional cartesian coordinate system of positive integers. example: Axis x = new Axis("x", 0, 100, 1); Axis y = new Axis("y", 0, 10, 1); Matrix<long> matrix = new Matrix<long>(new []{x

www.nuget.org

따라서 해당 package는 .NET Framework로 build 된 것이며 이와 같은 package가 .NET Standard에서만 가능한 API만 사용하는 경우 .NET project에서도 사용할 수 있습니다.

AssembliesAndNamespaces project에서 아래와 같이 Dialect Software의 package를 참조 추가합니다.

  <ItemGroup>
    <PackageReference Include="DialectSoftware.Collections.Matrix" Version="1.0.0" />
  </ItemGroup>

그리고 Program.cs에서 DialectSoftware.Collections과 DialectSoftware.Collections.Generics를 import 하고 아래와 같이 Axis와 Matrix<T>의 instance를 생성하고 값을 채워 넣은 다음 해당 값을 표시하는 문을 추가합니다.

Axis x = new Axis("x", 0, 100, 1);
Axis y = new Axis("y", 0, 10, 1);

Matrix<long> matrix = new Matrix<long>(new[] { x, y });

int i = 0;
for (; i < matrix.Axes[0].Points.Length; i++)
{
    matrix.Axes[0].Points[i].Label = "x" + i.ToString();
}

i = 0;
for (; i < matrix.Axes[1].Points.Length; i++)
{
    matrix.Axes[1].Points[i].Label = "y" + i.ToString();
}

foreach (long[] c in matrix)
{
    matrix[c] = c[0] + c[1];
}

foreach (long[] c in matrix)
{
    Console.WriteLine("{0},{1} ({2},{3}) = {4}", matrix.Axes[0].Points[c[0]].Label, matrix.Axes[1].Points[c[1]].Label, c[0], c[1], matrix[c]);
}

Project를 실행하면 다음과 같은 결과를 표시할 것입니다.

6. Preview 기능 사용하기

Microsoft는 주기적으로 runtime, 언어 compiler, API library등 .NET의 많은 부분에 전역적으로 영향을 미치는 새로운 기능을 제공합니다. 그런데 실질적으로 Microsoft가 기능에 필요한 대부분의 작업을 완료했다고 하더라도 .NET release에 대한 주기 때까지는 배포가 이루어지지 않을 것입니다. 문제는 이렇게 되면 실전에서 적절한 test를 하기에는 너무 늦다는 것입니다.

따라서 .NET 6부터 Microsoft는 GA(general availability) release에서는 preview 기능을 포함하게 되었습니다. 개발자는 이들 미리 보기 기능을 선택하고 Microsoft에게 feedback을 제공할 수 있습니다. 최신 GA release는 모두가 사용할 수 있습니다.

Preview 기능에 관한 내용임에 주의해야 합니다. .NET 혹은 Visual Studio에 대한 preview version과는 다릅니다. Microsoft는 Visual Studio와 .NET에 대한 preview version을 개발자들로부터 feedback을 얻고자 개발 중에 release 하며 그런 뒤 최종 GA를 release 합니다. 이때 GA가 모두가 사용가능한 기능이 되는 것입니다. GA이전에는 새로운 기능을 경험해 볼 수 있는 방법은 preview version을 설치하는 것입니다. Preview 기능은 GA release와 함께 설치되며 선택적으로 사용가능해야 하므로 다르다고 할 수 있습니다.

예를 들어 Microsoft는 .NET SDK 6.0.200를 2022년 02월에 release 했는데 이것은 C# 11 compiler를 preview 기능으로서 포함시켰습니다. 이는 .NET 6 개발자가 선택적으로 언어의 version을 preview로 설정할 수 있었음을 의미하며 이것으로 raw string literal과 required keyword 같은 C# 11 기능을 사용해 볼 수 있었습니다.

Preivew 기능은 production code에서는 지원하지 않으며 최종 release전에 대폭적인 변화가 있을 가능성이 있습니다. 따라서 오로지 test목적으로만 사용해야 합니다.

(1) Preview 기능이 필요한 경우

[RequiresPreviewFeatures] attribute는 사용하는 assembly, type 또는 member를 나타내는 데 사용되며 Code analyzer는 해당 assembly를 scan 하고 필요하다면 경고를 생성하게 됩니다. 만약 code에서 어떠한 preview 기능도 사용하지 않는다면 어떠한 경고 message도 보지 않게 될 테지만 그렇지 않다면 preview 기능을 사용한다는 경고를 해당 code를 사용하는 이에게 표시하게 됩니다.

(2) Preview 기능 사용

csproj(project file)에서 아래와 같이 preview 기능과 preview 언어 기능을 사용하기 위한 요소를 추가합니다.

<Nullable>enable</Nullable>
<EnablePreviewFeatures>true</EnablePreviewFeatures>
<LangVersion>preview</LangVersion>