C# 버전별 주요 변경사항 정리 🚀

C#은 마이크로소프트에서 개발한 강력한 객체 지향 프로그래밍 언어로, 지속적인 발전을 거듭하며 개발자들에게 더 나은 도구와 기능을 제공해왔습니다. 이 글에서는 C#의 주요 버전별 변경사항을 상세히 살펴보며, 각 버전이 어떻게 언어를 더욱 강력하고 유연하게 만들었는지 알아보겠습니다. 프로그램 개발에 관심 있는 분들이나 C# 개발자들에게 유용한 정보가 될 것입니다. 마치 재능넷에서 다양한 재능을 거래하듯이, C#도 각 버전마다 새로운 '재능'을 선보이며 진화해왔습니다. 그럼 지금부터 C#의 흥미진진한 여정을 함께 살펴볼까요? 😊

C# 1.0 - 기초를 다지다 (2002년) 🏗️

C# 1.0은 2002년에 처음 등장했습니다. 이 버전은 C#의 기본적인 구조와 특징을 확립했습니다.

주요 특징:

• 객체 지향 프로그래밍: 클래스, 인터페이스, 상속 등의 개념 도입
• 강력한 타입 시스템: 정적 타입 검사를 통한 안정성 확보
• 가비지 컬렉션: 자동 메모리 관리 기능 제공
• 속성(Properties): 필드에 대한 접근을 캡슐화하는 편리한 방법 제공
• 이벤트와 대리자: 이벤트 기반 프로그래밍 지원

C# 1.0은 Java와 C++의 장점을 결합하여 현대적이고 안전한 프로그래밍 언어를 목표로 했습니다. 이 버전에서 제공된 기능들은 지금까지도 C#의 핵심을 이루고 있습니다.

// C# 1.0 예제 코드
public class Person
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public event EventHandler NameChanged;

    protected virtual void OnNameChanged()
    {
        NameChanged?.Invoke(this, EventArgs.Empty);
    }
}

C# 2.0 - 생산성 향상 (2005년) 🚀

C# 2.0은 2005년에 출시되었으며, 개발자의 생산성을 크게 향상시키는 여러 기능을 도입했습니다.

주요 변경사항:

• 제네릭(Generics): 타입 안전성과 코드 재사용성 향상
• 부분 클래스(Partial Classes): 클래스 정의를 여러 파일로 분할 가능
• 익명 메서드(Anonymous Methods): 이름 없는 인라인 메서드 정의 가능
• 반복자(Iterators): yield return을 사용한 간편한 열거자 구현
• 널 조건부 연산자(Null-conditional Operator): ?. 연산자 도입

이 버전에서 도입된 제네릭은 C# 프로그래밍에 혁명적인 변화를 가져왔습니다. 타입 안전성을 유지하면서도 재사용 가능한 코드를 작성할 수 있게 되었죠. 마치 재능넷에서 다양한 재능을 효율적으로 관리하듯이, 제네릭을 통해 다양한 타입을 효과적으로 다룰 수 있게 된 것입니다.

// C# 2.0 제네릭 예제
public class GenericList<T>
{
    private T[] items;
    private int count;

    public void Add(T item)
    {
        if (count == items.Length)
            ResizeArray();
        items[count++] = item;
    }

    private void ResizeArray()
    {
        T[] newItems = new T[items.Length * 2];
        Array.Copy(items, newItems, items.Length);
        items = newItems;
    }
}

// 사용 예
GenericList<int> numbers = new GenericList<int>();
numbers.Add(10);
numbers.Add(20);

GenericList<string> names = new GenericList<string>();
names.Add("Alice");
names.Add("Bob");

이 예제에서 볼 수 있듯이, 제네릭을 사용하면 동일한 로직을 다양한 타입에 적용할 수 있습니다. 이는 코드 중복을 줄이고 타입 안전성을 보장하는 데 큰 도움이 됩니다.

부분 클래스(Partial Classes)의 활용

부분 클래스는 대규모 프로젝트에서 특히 유용합니다. 클래스의 정의를 여러 파일로 나눌 수 있어, 코드의 구조화와 관리가 용이해집니다.

// File1.cs
public partial class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

// File2.cs
public partial class Customer
{
    public void SendEmail(string message)
    {
        // 이메일 전송 로직
    }
}

이렇게 하면 클래스의 속성과 메서드를 논리적으로 분리할 수 있어, 코드의 가독성과 유지보수성이 향상됩니다.

익명 메서드(Anonymous Methods)의 도입

익명 메서드는 delegate를 사용할 때 매우 유용합니다. 메서드를 별도로 정의하지 않고도 인라인으로 작성할 수 있어 코드가 간결해집니다.

public delegate void PrintDelegate(string message);

class Program
{
    static void Main()
    {
        PrintDelegate printMethod = delegate(string message)
        {
            Console.WriteLine(message);
        };

        printMethod("Hello, Anonymous Method!");
    }
}

이 예제에서는 PrintDelegate 타입의 delegate를 익명 메서드로 구현했습니다. 이는 나중에 C# 3.0에서 도입된 람다 표현식의 전신이 되었습니다.

반복자(Iterators)의 강력함

C# 2.0에서 도입된 반복자는 컬렉션을 순회하는 로직을 매우 간단하게 구현할 수 있게 해줍니다. yield return 키워드를 사용하여 열거자를 쉽게 만들 수 있습니다.

public class Fibonacci
{
    public IEnumerable<int> GetSequence(int count)
    {
        int current = 0, next = 1;
        for (int i = 0; i < count; i++)
        {
            yield return current;
            int temp = current;
            current = next;
            next = temp + next;
        }
    }
}

// 사용 예
Fibonacci fib = new Fibonacci();
foreach (int num in fib.GetSequence(10))
{
    Console.WriteLine(num);
}

이 예제는 피보나치 수열을 생성하는 반복자를 보여줍니다. yield return을 사용함으로써, 전체 시퀀스를 메모리에 저장하지 않고도 필요할 때마다 다음 값을 생성할 수 있습니다.

C# 3.0 - 함수형 프로그래밍의 도입 (2007년) 🧠

C# 3.0은 2007년에 출시되었으며, 함수형 프로그래밍 패러다임을 C#에 도입했습니다. 이 버전은 LINQ(Language Integrated Query)와 같은 혁신적인 기능을 통해 데이터 조작을 더욱 쉽고 강력하게 만들었습니다.

주요 변경사항:

• LINQ (Language Integrated Query): 데이터 쿼리를 위한 통합 언어 기능
• 람다 표현식(Lambda Expressions): 간결한 익명 함수 작성
• 확장 메서드(Extension Methods): 기존 타입에 새로운 메서드 추가
• 자동 구현 속성(Auto-Implemented Properties): 간단한 속성 정의
• 익명 타입(Anonymous Types): 이름 없는 클래스 즉석 생성
• 객체 및 컬렉션 초기화자(Object and Collection Initializers): 객체 생성 및 초기화 간소화

C# 3.0의 가장 큰 특징은 LINQ의 도입입니다. LINQ는 데이터 소스에 관계없이 일관된 방식으로 데이터를 쿼리할 수 있게 해주는 강력한 도구입니다. 마치 재능넷에서 다양한 재능을 쉽게 검색하고 필터링할 수 있는 것처럼, LINQ를 사용하면 복잡한 데이터 구조에서도 원하는 정보를 쉽게 추출할 수 있습니다.

// LINQ 예제
var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

foreach (var num in evenNumbers)
{
    Console.WriteLine(num);
}

// 람다 표현식을 사용한 LINQ
var oddNumbers = numbers.Where(x => x % 2 != 0);

이 예제에서 볼 수 있듯이, LINQ를 사용하면 컬렉션에서 특정 조건을 만족하는 요소를 쉽게 필터링할 수 있습니다. 또한 람다 표현식을 사용하여 더욱 간결한 코드를 작성할 수 있습니다.

확장 메서드(Extension Methods)의 활용

확장 메서드는 기존 타입을 수정하지 않고도 새로운 메서드를 추가할 수 있게 해줍니다. 이는 특히 라이브러리나 프레임워크를 사용할 때 유용합니다.

public static class StringExtensions
{
    public static bool IsValidEmail(this string email)
    {
        // 이메일 유효성 검사 로직
        return email.Contains("@") && email.Contains(".");
    }
}

// 사용 예
string email = "example@example.com";
bool isValid = email.IsValidEmail();

이 예제에서는 string 타입에 IsValidEmail이라는 새로운 메서드를 추가했습니다. 이제 모든 string 객체에서 이 메서드를 사용할 수 있습니다.

자동 구현 속성(Auto-Implemented Properties)

자동 구현 속성은 간단한 속성을 더욱 간결하게 정의할 수 있게 해줍니다.

// C# 2.0
public class Person
{
    private string name;
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

// C# 3.0
public class Person
{
    public string Name { get; set; }
}

이렇게 간단한 속성을 정의할 때 코드량을 크게 줄일 수 있습니다.

익명 타입(Anonymous Types)

익명 타입을 사용하면 임시로 사용할 객체를 쉽게 만들 수 있습니다. 이는 LINQ 쿼리 결과를 저장하거나 임시 데이터 구조를 만들 때 유용합니다.

var person = new { Name = "John", Age = 30 };
Console.WriteLine($"{person.Name} is {person.Age} years old.");

// LINQ와 함께 사용
var query = from c in customers
            select new { c.Name, c.City };

이러한 기능들은 C#을 더욱 표현력 있고 생산적인 언어로 만들었습니다. 특히 LINQ의 도입은 데이터 처리 방식에 혁명을 가져왔으며, 이는 현대 C# 프로그래밍의 핵심 요소가 되었습니다.

C# 4.0 - 동적 프로그래밍과 상호 운용성 향상 (2010년) 🌐

C# 4.0은 2010년에 출시되었으며, 동적 프로그래밍 지원과 다른 프로그래밍 모델과의 상호 운용성을 크게 개선했습니다. 이 버전은 특히 COM 인터페이스나 동적 언어와의 통합을 용이하게 만들었습니다.

주요 변경사항:

• 동적 바인딩(Dynamic Binding): dynamic 키워드 도입
• 명명된 및 선택적 매개변수(Named and Optional Parameters): 메서드 호출 유연성 증가
• 제네릭 공변성 및 반공변성(Generic Covariance and Contravariance): 제네릭 타입의 유연성 향상
• Embedded Interop Types: COM 상호 운용성 개선

C# 4.0의 가장 큰 특징은 dynamic 키워드의 도입입니다. 이를 통해 C#은 정적 타입 언어의 장점을 유지하면서도 동적 타입 언어의 유연성을 얻게 되었습니다. 마치 재능넷에서 다양한 재능을 유연하게 활용할 수 있는 것처럼, dynamic을 사용하면 컴파일 시점에 타입을 알 수 없는 객체도 쉽게 다룰 수 있게 되었습니다.

// Dynamic 사용 예제
dynamic obj = "Hello, World!";
Console.WriteLine(obj.Length);  // 컴파일 시점에는 Length 속성의 존재를 확인하지 않음

obj = 42;
Console.WriteLine(obj * 2);  // 동적으로 타입이 변경되어도 문제 없음

이 예제에서 볼 수 있듯이, dynamic을 사용하면 객체의 타입을 런타임에 결정할 수 있습니다. 이는 특히 COM 객체나 동적 언어와의 상호 작용에서 매우 유용합니다.

명명된 및 선택적 매개변수(Named and Optional Parameters)

명명된 및 선택적 매개변수는 메서드 호출의 유연성을 크게 향상시켰습니다. 이를 통해 코드의 가독성이 높아지고, 메서드 오버로딩의 필요성이 줄어들었습니다.

public void DisplayGreeting(string name, string greeting = "Hello", bool uppercase = false)
{
    if (uppercase)
        Console.WriteLine($"{greeting.ToUpper()}, {name.ToUpper()}!");
    else
        Console.WriteLine($"{greeting}, {name}!");
}

// 사용 예
DisplayGreeting("Alice");  // 기본값 사용
DisplayGreeting("Bob", greeting: "Hi");  // 명명된 매개변수 사용
DisplayGreeting("Charlie", uppercase: true);  // 선택적 매개변수 건너뛰기

이 예제에서는 greeting과 uppercase가 선택적 매개변수로 정의되어 있습니다. 메서드 호출 시 이들 매개변수를 생략하거나, 명명된 매개변수를 사용하여 특정 매개변수만 지정할 수 있습니다.

제네릭 공변성 및 반공변성(Generic Covariance and Contravariance)

제네릭 공변성과 반공변성은 제네릭 타입의 유연성을 크게 향상시켰습니다. 이를 통해 제네릭 인터페이스와 델리게이트에서 더 유연한 타입 관계를 정의할 수 있게 되었습니다.

// 공변성 예제
IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings;  // 공변성 덕분에 가능

// 반공변성 예제
Action<object> actObject = (object o) => Console.WriteLine(o);
Action<string> actString = actObject;  // 반공변성 덕분에 가능

공변성(out 키워드)은 더 구체적인 타입에서 더 일반적인 타입으로의 암시적 변환을 허용하며, 반공변성(in 키워드)은 그 반대의 경우를 허용합니다. 이는 제네릭 프로그래밍의 유연성을 크게 향상시켰습니다.

Embedded Interop Types

Embedded Interop Types 기능은 COM 컴포넌트와의 상호 운용성을 크게 개선했습니다. 이 기능을 통해 Primary Interop Assembly(PIA)에 대한 의존성을 줄이고, 배포를 간소화할 수 있게 되었습니다.

// COM 인터페이스 사용 예제
[ComImport]
[Guid("00000000-0000-0000-C000-000000000046")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IUnknown
{
    [PreserveSig]
    int QueryInterface(ref Guid riid, out IntPtr ppvObject);

    [PreserveSig]
    int AddRef();

    [PreserveSig]
    int Release();
}

이 예제에서는 COM 인터페이스를 C#에서 직접 정의하고 사용할 수 있습니다. Embedded Interop Types 기능을 통해 이러한 인터페이스 정의가 어셈블리에 직접 포함되어, 별도의 PIA 없이도 COM 컴포 넌트와 상호 작용할 수 있게 되었습니다.

C# 5.0 - 비동기 프로그래밍의 혁명 (2012년) ⚡

C# 5.0은 2012년에 출시되었으며, 비동기 프로그래밍을 획기적으로 간소화했습니다. 이 버전의 핵심 기능은 async와 await 키워드의 도입으로, 복잡한 비동기 코드를 마치 동기 코드처럼 쉽게 작성할 수 있게 되었습니다.

주요 변경사항:

• async와 await 키워드: 비동기 프로그래밍 간소화
• 호출자 정보 특성(Caller Information Attributes): 메서드 호출에 대한 컴파일 시간 정보 제공

async와 await의 도입은 C# 프로그래밍에 있어 큰 변화를 가져왔습니다. 이전에는 복잡하고 오류가 발생하기 쉬웠던 비동기 프로그래밍이 훨씬 더 직관적이고 안전해졌습니다. 마치 재능넷에서 복잡한 프로젝트를 여러 단계로 나누어 효율적으로 관리하는 것처럼, async/await를 사용하면 복잡한 비동기 작업을 쉽게 관리할 수 있게 되었습니다.

// async/await 사용 예제
public async Task<string> DownloadContentAsync(string url)
{
    using (var client = new HttpClient())
    {
        return await client.GetStringAsync(url);
    }
}

// 사용 예
async Task Main()
{
    string content = await DownloadContentAsync("https://example.com");
    Console.WriteLine(content);
}

이 예제에서 볼 수 있듯이, async와 await를 사용하면 비동기 작업을 마치 동기 코드처럼 자연스럽게 작성할 수 있습니다. 이는 코드의 가독성을 크게 향상시키고, 동시에 UI 응답성을 유지하거나 서버 리소스를 효율적으로 사용할 수 있게 해줍니다.

호출자 정보 특성(Caller Information Attributes)

호출자 정보 특성은 메서드가 호출된 위치에 대한 정보를 쉽게 얻을 수 있게 해줍니다. 이는 로깅이나 디버깅에 특히 유용합니다.

public void LogMessage(string message,
    [CallerMemberName] string memberName = "",
    [CallerFilePath] string sourceFilePath = "",
    [CallerLineNumber] int sourceLineNumber = 0)
{
    Console.WriteLine($"Message: {message}");
    Console.WriteLine($"Member: {memberName}");
    Console.WriteLine($"Source File: {sourceFilePath}");
    Console.WriteLine($"Line Number: {sourceLineNumber}");
}

// 사용 예
public void SomeMethod()
{
    LogMessage("This is a log message");
}

이 예제에서 LogMessage 메서드를 호출할 때, 컴파일러는 자동으로 호출자의 정보(메서드 이름, 파일 경로, 라인 번호)를 채워 넣습니다. 이는 로그 메시지에 상세한 컨텍스트 정보를 추가하는 데 매우 유용합니다.

C# 6.0 - 문법의 개선과 편의성 향상 (2015년) 🛠️

C# 6.0은 2015년에 출시되었으며, 주로 기존 기능을 개선하고 새로운 편의 기능을 추가하는 데 초점을 맞췄습니다. 이 버전은 코드를 더 간결하고 표현력 있게 만드는 여러 가지 문법적 개선사항을 도입했습니다.

주요 변경사항:

• 문자열 보간(String Interpolation): 문자열 형식 지정 간소화
• null 조건 연산자(Null-conditional Operator): null 체크 간소화
• 식 본문 멤버(Expression-bodied Members): 간단한 메서드와 속성 정의 간소화
• using static: 정적 메서드 사용 간소화
• nameof 연산자: 심볼 이름을 문자열로 얻기
• 예외 필터(Exception Filters): 예외 처리 시 조건 지정
• 자동 속성 초기화(Auto-Property Initializers): 속성 초기화 간소화

이러한 기능들은 개발자의 생산성을 높이고 코드의 가독성을 개선하는 데 크게 기여했습니다. 마치 재능넷에서 다양한 도구를 사용해 작업을 더 효율적으로 수행하는 것처럼, C# 6.0의 새로운 기능들은 개발자가 더 쉽고 빠르게 코드를 작성할 수 있게 해주었습니다.

// 문자열 보간 예제
string name = "Alice";
int age = 30;
Console.WriteLine($"{name} is {age} years old.");

// null 조건 연산자 예제
string str = null;
int? length = str?.Length;

// 식 본문 멤버 예제
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Introduce() => $"My name is {Name} and I'm {Age} years old.";
}

// using static 예제
using static System.Math;
public class Circle
{
    public double Radius { get; set; }
    public double Area => PI * Pow(Radius, 2);
}

// nameof 연산자 예제
Console.WriteLine(nameof(Person.Name)); // 출력: "Name"

// 예외 필터 예제
try
{
    // 일부 코드
}
catch (Exception e) when (e.InnerException != null)
{
    // 내부 예외가 있는 경우에만 처리
}

// 자동 속성 초기화 예제
public class Person
{
    public string Name { get; set; } = "John Doe";
    public int Age { get; set; } = 30;
}

이러한 예제들은 C# 6.0에서 도입된 새로운 기능들이 어떻게 코드를 더 간결하고 표현력 있게 만드는지 보여줍니다. 특히 문자열 보간과 null 조건 연산자는 일상적인 코딩 작업을 크게 간소화했습니다.

C# 7.0-7.3 - 더 풍부한 표현력과 성능 향상 (2017-2018년) 🚀

C# 7.0부터 7.3까지는 2017년부터 2018년 사이에 연속적으로 출시되었습니다. 이 버전들은 언어의 표현력을 더욱 풍부하게 만들고, 동시에 성능을 향상시키는 데 초점을 맞췄습니다.

주요 변경사항:

• out 변수(C# 7.0): out 매개변수 선언 간소화
• 튜플(Tuples)(C# 7.0): 간단한 데이터 구조체 생성
• 패턴 매칭(Pattern Matching)(C# 7.0): 타입 검사와 캐스팅 간소화
• 로컬 함수(Local Functions)(C# 7.0): 메서드 내부에 함수 정의
• ref 반환 및 로컬(C# 7.0): 값 타입의 참조 반환 및 저장
• 비동기 Main 메서드(C# 7.1): 프로그램의 진입점을 비동기로 정의
• default 리터럴 표현식(C# 7.1): 타입의 기본값 간단히 표현
• 튜플 이름 추론(C# 7.1): 튜플 요소 이름 자동 추론
• in 매개변수(C# 7.2): 읽기 전용 참조로 매개변수 전달
• ref readonly 반환(C# 7.2): 읽기 전용 참조 반환
• stackalloc 배열 초기화(C# 7.3): 스택 할당 배열 초기화 간소화
• 향상된 제네릭 제약 조건(C# 7.3): Enum, Delegate에 대한 제네릭 제약 조건

이러한 기능들은 C#을 더욱 강력하고 유연한 언어로 만들었습니다. 특히 튜플과 패턴 매칭의 도입은 함수형 프로그래밍 스타일을 더 쉽게 적용할 수 있게 해주었습니다. 마치 재능넷에서 다양한 전문가들의 기술을 조합하여 복잡한 프로젝트를 해결하는 것처럼, 이러한 새로운 기능들은 개발자가 더 복잡한 문제를 더 우아하게 해결할 수 있게 해주었습니다.