프로그래밍 허브

📘 개념 요약

💻 실제 코드 성능 비교 예제

// Thread 방식
for (int i = 0; i < 5; i++)
{
    new Thread(() =>
    {
        Console.WriteLine($"[Thread] 작업 {i} - ID: {Thread.CurrentThread.ManagedThreadId}");
        Thread.Sleep(200);
    }).Start();
}

// Task 방식
for (int i = 0; i < 5; i++)
{
    Task.Run(() =>
    {
        Console.WriteLine($"[Task] 작업 {i} - ID: {Thread.CurrentThread.ManagedThreadId}");
        Thread.Sleep(200);
    });
}

// Parallel 방식
Parallel.For(0, 5, i =>
{
    Console.WriteLine($"[Parallel] 작업 {i} - ID: {Thread.CurrentThread.ManagedThreadId}");
    Thread.Sleep(200);
});

🧠 성능 비교 (정량적 요약)

🧪 실제 성능 차이 실험 (예시 시나리오)

작업 수: 1000개, 각각 50ms 대기

• Thread:
  • 생성 비용 ↑
  • 컨텍스트 스위칭 많음 → CPU 부하 증가
  • 스레드 개수 많아지면 성능 급하락
• Task:
  • 스레드 풀 기반이라 리소스 절약
  • 처리 속도 일정, 확장성 우수
• Parallel:
  • CPU 코어 수만큼 자동 분할 실행
  • 단순 반복문에서는 최강 성능

🔧 사용법 요약

📝 결론 요약

• Thread는 지금은 거의 특수 상황에만 사용됨 (직접 스레드 제어 필요할 때)
• Task는 범용 병렬 처리 및 비동기 처리의 기본
• Parallel은 반복 작업의 병렬 최적화에 최적

💡 실무에서는 대부분 Task와 Parallel을 사용하며, Thread는 병렬 제어가 필요한 특수 케이스에서만 권장됩니다.

🏷 추천 태그

C#, Thread, Task, Parallel, 스레드 풀, 병렬처리, 멀티스레딩, 성능 비교, 비동기, Concurrency, 스레드 최적화

🎯 실전 팁

• async/await 기반 Task는 비동기 I/O 작업에 최적
• Parallel.For는 CPU 바운드 작업에 최적
• 병렬 작업 수가 많고 짧을수록 Task 또는 Parallel을,
  작업 시간이 길고 독립적일수록 Thread를 사용하면 됩니다.

📘 개념 요약

람다식은 C#에서 익명 메서드를 간단하게 표현하는 방식입니다. 특히 LINQ, delegate, 이벤트, 비동기 콜백 등에서 많이 사용되며, 코드를 간결하게 만들어줍니다.

🧠 용어 설명

💻 기본 형식

입력 => 식 or 블록

x => x > 10       // 하나의 입력, 조건 필터링
(x, y) => x + y   // 두 개의 입력, 계산 결과 반환
() => Console.WriteLine("Hello")  // 입력 없음

💡 LINQ에서의 예제

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// 짝수만 필터링
var evens = numbers.Where(n => n % 2 == 0);

foreach (var n in evens)
    Console.WriteLine(n);  // 출력: 2, 4

n => n % 2 == 0 은 n이라는 입력을 받아서, 짝수인지 검사하여 true/false 반환하는 Predicate<int> 형식입니다.

🔧 다양한 람다식 예시

🛑 주의사항

• 블록이 여러 줄일 경우 {} 중괄호와 return 필수:

Func<int, int> square = x =>
{
    int result = x * x;
    return result;
};

• 람다식 안에서 외부 변수 참조 시 캡처됨 (클로저):

int baseNum = 10;
var result = numbers.Select(n => n + baseNum);

📝 정리

🏷 추천 태그

C#, 람다식, LINQ, 익명 함수, Predicate, Func, Action, delegate, 콜백, 클로저

📘 개념 요약

인터페이스와 의존성 주입(DI)은 객체 지향 설계의 핵심으로, 결합도를 낮추고, 확장 가능하고 테스트 가능한 구조를 만드는 데 필수입니다.

🧠 용어 설명

💻 코드 예제

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[로그]: {message}");
    }
}

public class App
{
    private readonly ILogger _logger;
    public App(ILogger logger)
    {
        _logger = logger;
    }

    public void Run()
    {
        _logger.Log("프로그램 시작됨.");
    }
}

🔧 사용법 정리

• 테스트 시 FakeLogger 등으로 쉽게 교체 가능
• ASP.NET Core에서는 생성자 기반 DI 기본 제공
• 유지보수성과 모듈화 향상

🏷 추천 태그

C#, DI, 의존성 주입, 인터페이스, 객체지향 설계, 테스트 가능 코드, SOLID, IoC, 유지보수

📘 개념 요약

LINQ는 C# 컬렉션을 SQL처럼 다루는 문법으로, 데이터를 필터링하고 가공하는 강력한 도구입니다. 리스트, 배열, DB, XML, JSON 등 다양한 소스에 적용할 수 있습니다.

🧠 용어 설명

💻 코드 예제

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

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        // 짝수 필터링
        var evens = numbers.Where(n => n % 2 == 0);

        Console.WriteLine("짝수 목록:");
        foreach (var n in evens)
            Console.WriteLine(n);
    }
}

🔧 사용법 정리

• 람다식 (n => 조건): 간결하게 필터링
• IEnumerable<T>: LINQ 결과는 지연 평가(lazy evaluation)
• ToList() 사용 시 즉시 평가

🏷 추천 태그

C#, LINQ, 람다, 데이터 처리, Where, Select, 프로그래밍, 컬렉션 처리, IEnumerable

📘 개념 요약

비동기 메서드는 기본적으로 async와 await 키워드를 사용하여 비동기적으로 실행됩니다. 하지만 콘솔 앱이나 초기 Main() 함수 등에서는 비동기 메서드를 동기 방식으로 실행해야 할 때가 있습니다.

이를 위해 사용하는 대표적인 방법이 다음 두 가지입니다:

1. Task.Wait()
2. Task.GetAwaiter().GetResult()

🧠 용어 설명

💻 예제 1 – DownloadDataAsync().Wait();

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    public static async Task DownloadDataAsync()
    {
        using (HttpClient client = new HttpClient())
        {
            string result = await client.GetStringAsync("https://jsonplaceholder.typicode.com/posts/1");
            Console.WriteLine("응답 데이터:");
            Console.WriteLine(result);
        }
    }

    static void Main(string[] args)
    {
        try
        {
            // 비동기 메서드를 동기적으로 대기
            DownloadDataAsync().Wait();  
        }
        catch (AggregateException ex)
        {
            Console.WriteLine($"예외 발생: {ex.InnerException?.Message}");
        }
    }
}

✅ 특징:

• Wait()은 현재 스레드를 멈춰서 기다림
• 예외 발생 시 AggregateException으로 감싸짐

💻 예제 2 – DownloadDataAsync().GetAwaiter().GetResult();

static void Main(string[] args)
{
    try
    {
        // 비동기 메서드를 동기적으로 결과 획득
        DownloadDataAsync().GetAwaiter().GetResult();
    }
    catch (Exception ex)
    {
        Console.WriteLine($"예외 발생: {ex.Message}");
    }
}

✅ 특징:

• .GetAwaiter().GetResult()는 예외를 감싸지 않고 직접 던짐
• Wait()보다 디버깅 시 유리함

🔧 언제 어떤 걸 써야 할까?

// C# 7.1 이상에서 가장 좋은 방법
static async Task Main(string[] args)
{
    await DownloadDataAsync();
}

📝 핵심 정리

🏷 추천 태그

C#, 비동기, Task, async await, GetAwaiter, Wait, 예외처리, 콘솔앱, UI 데드락, 프로그래밍 기초, 동기 vs 비동기, 코드 분석

1. WPF란?

• 정의:
  WPF는 데스크톱 클라이언트 애플리케이션 개발을 위한 UI 프레임워크로, 마이크로소프트의 .NET Framework의 하위 집합입니다.
• 주요 특징:
  • 애플리케이션 모델, 리소스, 컨트롤, 그래픽, 레이아웃, 데이터 바인딩, 문서, 보안 등 다양한 기능 제공.
  • **XAML(Extensible Application Markup Language)**을 사용한 선언적 프로그래밍 모델 지원.

2. WPF의 주요 구성 요소

1. XAML (Extensible Application Markup Language):
   • 역할:
     UI를 선언적으로 정의하는 언어.
   • 특징:
     • 화면 구성 요소(버튼, 텍스트박스 등)를 XML 기반 문법으로 표현.
     • XAML 코드와 디자인 뷰는 상호 동기화.
     • 예시:
       

       <Window x:Class="WPFExample.MainWindow"
               xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
               xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
               Title="MainWindow" Height="350" Width="525">
           <Grid>
               <Button Content="Click Me" Width="100" Height="50" />
           </Grid>
       </Window>

       
       
       
2. Code-Behind (C# 파일):
   • 역할:
     애플리케이션의 동작을 정의하는 논리 코드 작성.
   • 구성:
     • 이벤트 핸들러, 클래스 정의 등을 포함.
   • 예시:
      

     using System.Windows;
     
     namespace WPFExample
     {
         public partial class MainWindow : Window
         {
             public MainWindow()
             {
                 InitializeComponent();
             }
     
             private void Button_Click(object sender, RoutedEventArgs e)
             {
                 MessageBox.Show("Button clicked!");
             }
         }
     }

3. 디자인 뷰와 XAML 뷰:
   • 디자인 뷰: 시각적으로 UI를 구성할 수 있는 화면.
   • XAML 뷰: XML 문법으로 구성된 UI 코드 확인 및 편집.
   • 양방향 동기화:
     • 디자인 뷰에서 요소를 추가하면 XAML 코드 자동 수정.
     • XAML 코드 변경 시 디자인 뷰도 업데이트.

3. WPF의 주요 기능

1. 레이아웃 시스템:
   • 유연한 레이아웃 관리.
   • 컨트롤 크기와 위치를 동적으로 조정 가능.
   • 레이아웃 컨테이너:
     • Grid, StackPanel, DockPanel, WrapPanel 등.
2. 데이터 바인딩:
   • UI 요소와 데이터를 동기화.
   • 모델-뷰-뷰모델(MVVM) 패턴과 통합.
3. 그래픽과 애니메이션:
   • 2D 및 3D 그래픽 지원.
   • 복잡한 애니메이션 효과를 손쉽게 구현.
4. 스타일과 리소스:
   • UI의 모양과 느낌을 정의.
   • 전역 리소스를 사용하여 통일된 스타일 제공.
5. 문서 및 텍스트:
   • 고급 텍스트 렌더링.
   • 문서 및 텍스트 관련 기능 강화.
6. 보안:
   • 사용 권한 및 애플리케이션 신뢰도 관리.

4. WPF 개발 프로세스

1. 화면 구성:
   • 디자인 뷰에서 화면 레이아웃을 구성하거나, XAML 뷰에서 직접 코드 작성.
2. 동작 정의:
   • Code-Behind 파일에서 동작(이벤트 처리)을 정의.
3. 클래스 추가:
   • 필요 시 추가 클래스 정의 및 데이터 모델 구성.
4. 빌드 및 실행:
   • 오류가 없는지 빌드 확인 후 실행.
5. 테스트 및 디버깅:
   • 실행 후 동작 확인 및 버그 수정.

5. WPF와 다른 UI 프레임워크 비교

특징WPFWindows FormsUWP (Universal Windows Platform)

6. WPF의 장점

1. 풍부한 UI:
   • 고급 그래픽, 애니메이션, 3D 렌더링 지원.
2. 데이터 중심 개발:
   • 강력한 데이터 바인딩과 MVVM 패턴 지원.
3. 유연한 디자인:
   • 전역 스타일 및 리소스를 사용해 UI를 일관성 있게 관리.
4. 생산성 향상:
   • XAML과 C#의 분리로 역할 분담 가능.
5. 고성능:
   • 하드웨어 가속을 통한 고속 렌더링.

7. WPF의 한계

1. Windows 전용:
   • 크로스 플랫폼 지원 부족.
2. 복잡성:
   • 기능이 많아 학습 곡선이 높음.
3. UWP 및 .NET MAUI의 대두:
   • 최신 프레임워크 대비 시장 점유율 감소.

8. WPF 사용 사례

• 비즈니스 애플리케이션:
  • 데이터 입력 및 분석 도구.
• 그래픽 집약적 애플리케이션:
  • 3D 모델링 도구, 멀티미디어 소프트웨어.
• 데스크톱 애플리케이션:
  • 고급 사용자 인터페이스가 필요한 클라이언트 응용 프로그램.

9. 요약

• WPF는 데스크톱 클라이언트 애플리케이션 개발을 위한 유연하고 강력한 UI 프레임워크입니다.
• XAML을 활용한 선언적 UI와 C#을 통한 동작 정의로 효율적인 개발 환경을 제공합니다.
• 데이터 바인딩, 고급 그래픽, 유연한 레이아웃 등 현대적인 UI 개발의 모든 기능을 갖추고 있습니다.

1. 상수(Constant)

• 정의: 값을 절대 변경할 수 없는 메모리 공간.
• 선언 방법:

const 자료형 상수명 = 값;

• 예시:

const int a = 30; 
const string greeting = "Hello, World!";

2. 열거 형식(Enum)

• 정의: 종류는 같지만 서로 다른 값을 가지는 상수의 집합.
• 기반 자료형: 정수 계열만 사용 가능 (byte, sbyte, short, ushort, int, uint, long, ulong, char). 기본값은 int.

a. 선언 방법

enum 열거형식명 : 기반자료형 { 상수1, 상수2 } 
enum 열거형식명 { 상수1 = 값1, 상수2 = 값2 } 
enum 열거형식명 { 상수1 = 값1, 상수2, 상수3 = 값3 }

b. 예시

enum Color { Red = 1, Green = 2, Blue = 3 } 
enum Status : byte { Active = 1, Inactive = 0 }

c. 열거형 활용

• 값 확인:

Console.WriteLine((int)Color.Red); // 출력: 1

• 열거형 값을 문자열로 출력:

Console.WriteLine(Color.Green); // 출력: Green

3. Nullable 형식

• 정의: 값이 없을 수 있는 변수 형식.
• 선언 방법:

데이터형식? 변수이름;

a. 예시

int? a = null; // Nullable 형식 
if (a.HasValue) // 값이 있는지 확인
{
	Console.WriteLine(a.Value); 
} 
else 
{
	Console.WriteLine("No value"); 
}

b. Nullable 속성

• HasValue: 값이 있는지 확인 (true 또는 false).
• Value: 변수에 담긴 값 반환.

4. var 형식

• 정의: 변수에 담긴 데이터에 따라 컴파일러가 자동으로 형식을 지정.
• 주의사항:
  • 선언과 동시에 값을 초기화해야 함.
  • 지역 변수로만 사용 가능.

예시

var x = 10;        // 컴파일러가 int로 추론
var y = "Hello";   // 컴파일러가 string으로 추론
// var z;           // 오류: 초기화 필요

5. 공용 형식 시스템 (CTS)

• 정의: .NET 프레임워크의 형식 체계 표준.
• C#의 모든 데이터 형식은 CTS를 기반으로 하며, 다른 .NET 언어들과의 호환성을 보장.
• 예시:
  • C#의 int는 CTS의 System.Int32에 매핑.
  • C#의 string은 CTS의 System.String에 매핑.

정리

• 상수: 변경할 수 없는 고정된 값.
• 열거형: 특정 그룹의 상수를 관리하기 위한 형식.
• Nullable: 값이 없음을 표현.
• var: 데이터 형식을 자동 추론.
• CTS: .NET에서 데이터 형식의 표준을 정의.

1. 데이터 형식 개요

• 참조 형식: 문자열(string), 오브젝트(object) 형식으로 구분.
• 값 형식: 숫자 형식, 논리 형식으로 구분.
  • 숫자 형식: 정수 계열, 부동소수점 계열, 소수 계열로 세분화.

2. 정수 계열

정수 데이터를 다루기 위한 형식이며, 크기와 범위가 다릅니다.
효율적인 메모리 사용을 위해 데이터 범위에 맞는 형식을 선택해야 합니다.

데이터 형식설명크기(Byte)범위

양수와 음수 표현: 최상위 비트를 이용하여 0(양수), 1(음수)로 구분.
음수 표현: 2의 보수법

1. 비트를 반전.
2. 1을 더함.

예시: -3

• 00000011 → 비트 반전 → 11111100 → 1 추가 → 11111101

3. 오버플로우와 언더플로우

• 오버플로우: 데이터가 최대값을 넘으면 0으로 순환.
• 언더플로우: 데이터가 최소값을 넘으면 최대값으로 순환.

4. 부동소수점 계열

유리수와 실수를 표현하는 데이터 형식.
정수 계열보다 표현 범위가 넓지만 정확도 손실이 있을 수 있음.

데이터 형식설명크기(Byte)범위

5. 논리 형식 계열

참과 거짓을 표현.

데이터 형식설명크기(Byte)범위

6. 문자와 문자열 형식

• 문자(char): 단일 문자, 작은 따옴표 사용.

char c = 'A';

• 문자열(string): 여러 문자의 집합, 큰따옴표 사용.

string s = "Hello";

7. Object 형식

• 모든 데이터 형식의 조상.
• 참조 형식이며, 힙(Heap)에 데이터를 저장.

8. 박싱(Boxing)과 언박싱(Unboxing)

• 박싱: 값 형식 → 참조 형식(object)로 변환.

int a = 20; 
object o = a; // 박싱

• 언박싱: 참조 형식(object) → 값 형식으로 변환.

object o = 20; 
int a = (int)o; // 언박싱

9. 데이터 크기

• bit: 0과 1을 표현하는 최소 단위.
• 니블: 4비트.
• 바이트(byte): 8비트.
• 워드(word): CPU의 데이터 처리 단위(16비트 이상).

10. 데이터 구조

• 필드: 데이터베이스의 열(Column).
• 레코드: 데이터베이스의 행(Row).
• 파일: 레코드의 집합.
• 데이터베이스: 파일의 집합.

1. 증감 연산자

• 전위 증가 연산자 (++a):
  변수를 증가시킨 후 해당 구문을 실행.
• 후위 증가 연산자 (a++):
  해당 구문을 실행한 후 변수를 증가.

예시:

int a = 10; 
Console.WriteLine(a++); // 출력: 10 (증가는 이후에 실행) 
Console.WriteLine(++a); // 출력: 12 (증가는 먼저 실행)

2. 관계 연산자

• 논리형식(bool) 결과 반환 (true 또는 false).연산자설명 

  ==	두 피연산자가 같으면 true.
  !=	두 피연산자가 다르면 true.

예시:

int x = 5, y = 10; 
Console.WriteLine(x == y); // 출력: False 
Console.WriteLine(x != y); // 출력: True

3. 논리 연산자

• AND (&&): 두 조건이 모두 참일 때 true.
• OR (||): 하나라도 참이면 true.
• NOT (!): 논리값을 반전.

예시:

bool a = true, b = false; 
Console.WriteLine(a && b); // 출력: False 
Console.WriteLine(a || b); // 출력: True 
Console.WriteLine(!a); // 출력: False

4. 조건 연산자 (?:)

• 형식: 조건식 ? 참일 때 값 : 거짓일 때 값.
• 조건식의 결과는 논리값(true 또는 false).

예시:

int a = 30; 
string result = a == 30 ? "삼십" : "삼십 아님"; 
Console.WriteLine(result); // 출력: 삼십

5. Null 조건부 연산자 (?.)

• 형식: 객체?.멤버 또는 객체?[인덱스].
• 객체가 null이면 null 반환, 아니면 멤버에 접근.

예시:

class Foo 
{ 
	public int Member { get; set; } 
} 
Foo foo = null; 
int? bar = foo?.Member; // foo가 null이므로 bar는 null

6. Null 병합 연산자 (??)

• 형식: op1 ?? op2.
• op1이 null이면 op2 반환, 그렇지 않으면 op1 반환.

예시:

string message = null; 
string result = message ?? "Default message"; 
Console.WriteLine(result); // 출력: Default message​

7. 비트 연산자

• 왼쪽 시프트 (<<): 비트를 왼쪽으로 이동.
• 오른쪽 시프트 (>>): 비트를 오른쪽으로 이동.
• XOR (^): 두 비트가 다를 때 1.
• NOT (~): 모든 비트를 반전.

시프트 연산 예시:

int a = 240, b = 2; 
Console.WriteLine(a << b); // 출력: 960 (240 * 2^2) 
Console.WriteLine(a >> b); // 출력: 60 (240 / 2^2)​

정리

• 증감 연산자: 전위와 후위의 차이를 이해.
• 관계 및 논리 연산자: 분기와 조건 설정에 필수.
• 조건 연산자: 간단한 조건문 처리에 유용.
• Null 조건부 연산자: 객체가 null인지 확인 후 멤버 접근.
• Null 병합 연산자: null 기본값을 처리하는 데 활용.
• 비트 연산자: 낮은 수준의 데이터 조작에 필수.

int a = 256;
byte b = (byte)a; // b = 0 (오버플로우 발생)

c. 부호 있는 정수 → 부호 없는 정수

• 음수 값을 변환하면 언더플로우가 발생.
• 예: int → uint

int a = -1;
uint b = (uint)a; // b = 4294967295 (언더플로우)

3. 부동소수점 데이터 형식 변환

a. 부동소수점 → 정수

• 소수점 이하를 버리고 정수 값만 남습니다. 반올림은 하지 않습니다.
• 예:
   

double d = 3.9; 
int i = (int)d; // i = 3

b. float ↔ double 변환

• 부동소수점은 소수를 이진수로 저장하므로 정밀도 손실이 있을 수 있습니다.
• 예:

float f = 1.123456789f; // 제한된 정밀도 (7자리)
double d = f; // 정밀도가 손상될 수 있음

4. 문자와 숫자 변환

a. 문자 → 숫자

• Parse() 또는 Convert.ToInt32() 메소드를 사용.
• 예:

string s = "123"; 
int i = int.Parse(s); // i = 123

b. 숫자 → 문자

• ToString() 메소드를 사용.
• 예:

int i = 123; 
string s = i.ToString(); // s = "123"

5. 변환의 주의점

• 정수 변환: 범위 초과 여부 확인 (오버플로우/언더플로우).
• 부동소수점 변환: 정밀도 손실 가능성 이해.
• 문자와 숫자 변환: 잘못된 입력 처리 대비 (예외 처리).