Category
Preparing references and filters for this topic. 이 주제의 레퍼런스와 필터를 준비하고 있습니다.
Category Reference
기본 문법, 객체지향, 컬렉션, LINQ, records, pattern matching, async/await, DI까지 C#의 핵심 흐름을 카드형 레퍼런스로 정리합니다.
Search titles, summaries, tags, and subcategories.
Showing 58 cards.
Subcategory
11 cards
정수, 실수, 문자열, bool 등 C# 내장 타입의 메모리 크기와 범위, `var` 타입 추론, 리터럴 접미사, 타입 변환까지 기본 타입 전반을 정리합니다.
int score = 100;
long bigNum = 10_000_000_000L;
double pi = 3.14159;
float temp = 36.5f;
decimal price = 9.99m;
bool isReady = true;
char grade = 'A';
string name = "Mina";
var level = 3; // 컴파일러가 int로 추론
var msg = "hello"; // 컴파일러가 string으로 추론`using` directive와 `namespace`의 구조, file-scoped namespace, `global using`, alias — 이름 충돌을 피하고 코드 구조를 읽기 쉽게 만드는 방법을 정리합니다.
// 파일 상단 — namespace 가져오기
using System.Collections.Generic;
using Json = System.Text.Json.JsonSerializer; // alias
// 파일 스코프 namespace (C# 10+)
namespace Game.Services;
public class ScoreService
{
public List<int> Scores { get; } = new();
}산술·비교·논리·비트 연산자, short-circuit 평가, 연산자 우선순위, `=`와 `==` 혼동 방지까지 C# 연산자 전반을 정리합니다.
int total = price * count; // 산술
bool passed = score >= 60; // 비교
bool canEnter = age >= 20 && hasTicket; // 논리 AND
count += 1; // 복합 대입
string tag = isAdmin ? "admin" : "user"; // 삼항메서드의 구성 요소, 반환 타입, 매개변수 기본값과 named argument, 식 본문 메서드, 오버로딩까지 C# 메서드 전반을 정리합니다.
// 기본 메서드
int Add(int left, int right)
{
return left + right;
}
// 식 본문 (expression-bodied)
int Square(int x) => x * x;
// 반환값 없음
void Log(string message) => Console.WriteLine(message);
int sum = Add(2, 3); // 5문자열 불변성, 자주 쓰는 메서드, StringBuilder가 필요한 상황, 비교 방식까지 C# 문자열을 올바르게 다루는 핵심 패턴을 정리합니다.
string title = "RefDock";
int length = title.Length;
bool hasDock = title.Contains("Dock");
string upper = title.ToUpper();
string raw = " apple,banana,orange ";
string cleaned = raw.Trim();
string[] items = cleaned.Split(',');`$""` 보간, `@""` 축자 리터럴, `"""` 원시 문자열 리터럴의 차이와 서식 지정자, 성능 고려 사항을 정리합니다.
string name = "Mina";
int score = 1200;
decimal rate = 0.856m;
string msg = $"{name}님의 점수: {score:N0}점"; // "Mina님의 점수: 1,200점"
string pct = $"달성률: {rate:P1}"; // "달성률: 85.6%"
string date = $"기준일: {DateTime.Now:yyyy-MM-dd}";`Parse`와 `TryParse`의 내부 동작 차이, `NumberStyles`와 `CultureInfo`로 형식 제어, `Span<char>` 기반 파싱, 언제 예외를 쓰고 언제 bool 패턴을 쓸지 판단 기준을 정리합니다.
// Parse — 실패 시 예외 발생
int count = int.Parse("42");
// TryParse — 실패 시 false 반환
if (int.TryParse(userInput, out int value))
Process(value);
else
ShowError("숫자를 입력하세요");
// 무시 패턴 — 성공 여부만 확인
bool isNumber = int.TryParse(text, out _);DateTime, DateOnly, TimeSpan의 생성·연산·포맷, DateTimeOffset의 타임존 처리, 안전한 파싱 패턴을 정리합니다.
DateTime now = DateTime.Now;
DateTime utc = DateTime.UtcNow;
// 날짜 연산
DateTime tomorrow = now.AddDays(1);
TimeSpan diff = tomorrow - now; // TimeSpan
// 포맷
string s = now.ToString("yyyy-MM-dd HH:mm:ss");
// C# 10+ — 날짜만 / 시간만
DateOnly today = DateOnly.FromDateTime(now); // 2026-03-25
TimeOnly time = TimeOnly.FromDateTime(now); // 09:30:00string이 불변이라 루프에서 += 연결이 비효율적인 이유, StringBuilder의 내부 버퍼 동작, Append/Insert/Remove/Replace 메서드 패턴을 정리합니다.
var sb = new StringBuilder(256); // 초기 capacity 지정
sb.Append("이름: ").AppendLine("Mina");
sb.AppendFormat("점수: {0:N0}점", 1200);
sb.Insert(0, "=== 결과 ===\n");
sb.Replace("Mina", "민아");
string result = sb.ToString();nameof()의 리팩토링 안전성, typeof()와 GetType()의 차이, sizeof()의 값 타입 크기 확인 용도와 unsafe 없이 쓸 수 있는 범위를 정리합니다.
// nameof — 리팩토링 안전한 이름 문자열
void Save(string name)
{
ArgumentNullException.ThrowIfNull(name, nameof(name));
}
// typeof — 컴파일 시점 타입 객체
Type t = typeof(DateTime);
Console.WriteLine(t.FullName); // System.DateTime
// GetType — 런타임 실제 타입
object obj = "hello";
Console.WriteLine(obj.GetType()); // System.String
Console.WriteLine(obj.GetType() == typeof(string)); // true
// sizeof — 기본 값 타입 크기 (바이트)
int size = sizeof(int); // 4
int size2 = sizeof(long); // 8C# 8에서 도입된 System.Index(`^n`)와 System.Range(`start..end`)로 배열, 문자열, Span을 슬라이싱하는 방법, 커스텀 타입에 인덱서를 추가하는 패턴, 컴파일러 변환 원리와 upper-bound exclusive 주의점까지 정리합니다.
int[] nums = [10, 20, 30, 40, 50];
// System.Index — ^n은 끝에서 n번째
int last = nums[^1]; // 50
int secondLast = nums[^2]; // 40
// System.Range — start..end (end는 포함 안 됨)
int[] first3 = nums[0..3]; // [10, 20, 30]
int[] last2 = nums[^2..]; // [40, 50]
int[] middle = nums[1..^1]; // [20, 30, 40]
int[] all = nums[..]; // [10, 20, 30, 40, 50] 전체 복사
// 문자열에도 동일하게 적용
string s = "Hello, World!";
string sub = s[7..12]; // "World"
string tail = s[^6..]; // "orld!"5 cards
`if/else`, 삼항 연산자, 가드 클로즈 패턴의 차이와 단락 평가, 조건문 중첩을 줄이는 실전 구조를 정리합니다.
if (score >= 90)
grade = "A";
else if (score >= 80)
grade = "B";
else
grade = "C";
// 단순 이진 선택은 삼항 연산자가 더 짧다
string label = isActive ? "활성" : "비활성";값을 반환하는 `switch expression`이 `switch statement`와 어떻게 다른지, 패턴 매칭·`when` 가드·완전성 검사와 어떻게 결합하는지 정리합니다.
string label = state switch
{
GameState.Ready => "준비",
GameState.Playing => "진행 중",
GameState.Paused => "일시정지",
GameState.Over => "게임 오버",
_ => throw new ArgumentOutOfRangeException(nameof(state))
};`for`, `foreach`, `while`, `do-while`의 차이와 선택 기준, foreach가 내부적으로 작동하는 방식, 반복 중 컬렉션을 수정하면 안 되는 이유까지 정리합니다.
// 인덱스가 필요할 때
for (int i = 0; i < items.Count; i++)
{
Console.WriteLine($"[{i}] {items[i]}");
}
// 컬렉션을 읽기만 할 때
foreach (string name in names)
{
Console.WriteLine(name);
}
// 종료 시점이 조건 기반일 때
while (!queue.IsEmpty)
{
Process(queue.Dequeue());
}타입 패턴, 관계 패턴, 프로퍼티 패턴, `when` 가드의 동작 원리와 `is` 표현식·`switch` 분기에서 어떻게 조합하는지 정리합니다.
// 타입 패턴 — 타입 확인과 변수 선언을 한 번에
if (shape is Circle c)
Console.WriteLine($"반지름: {c.Radius}");
// switch expression + 관계 패턴
string grade = score switch
{
>= 90 => "A",
>= 80 and < 90 => "B",
>= 70 => "C",
< 0 => throw new ArgumentException(),
_ => "F"
};`and`/`or`/`not` 조합 패턴, 중첩 property pattern, positional pattern, list pattern으로 시퀀스를 분기하는 방법과 실용 예시를 정리합니다.
// and / or / not 조합
string category = score switch
{
>= 90 and <= 100 => "S",
>= 70 and < 90 => "A",
>= 50 and < 70 => "B",
< 0 or > 100 => throw new ArgumentOutOfRangeException(),
_ => "F"
};
// list pattern (C# 11+)
string describe = items switch
{
[] => "비어있음",
[var single] => $"하나: {single}",
[var first, ..] => $"첫 번째: {first}, 이후 더 있음"
};11 cards
클래스가 참조 타입인 이유, 필드·프로퍼티·메서드의 역할, object initializer, 정적 멤버, class vs record vs struct 선택 기준을 정리합니다.
public class Player
{
public string Name { get; set; }
public int Score { get; private set; }
public Player(string name) => Name = name;
public void AddScore(int points) => Score += points;
}
// 생성자로 인스턴스 생성
var player = new Player("Mina");
player.AddScore(10);
Console.WriteLine(player.Score); // 10
// object initializer (public setter가 있는 프로퍼티만 가능)
var p2 = new Player("Jin") { Name = "Jin Park" };생성자 오버로딩, `this()` 체이닝, primary constructor(C# 12), 정적 생성자의 역할과 팩토리 메서드와의 선택 기준을 정리합니다.
public class Player
{
public string Name { get; }
public int Level { get; private set; }
public Player(string name) : this(name, 1) { }
public Player(string name, int level)
{
Name = name;
Level = level;
}
}
var beginner = new Player("Mina");
var veteran = new Player("Jin", 50);자동 구현 프로퍼티, `init`, `required`, 계산 프로퍼티의 차이와 퍼블릭 필드 대신 프로퍼티를 쓰는 이유를 정리합니다.
public class Player
{
public string Name { get; set; } = ""; // 읽기/쓰기
public int Score { get; private set; } // 외부 읽기, 내부 쓰기
public int Level { get; init; } // 생성 시점에만 쓰기
// 계산 프로퍼티 — 저장 없이 매번 계산
public string Title => Score >= 1000 ? "Pro" : "Novice";
}`interface`가 컴파일러에서 vtable로 구현되는 방식, 다중 구현, 기본 구현 메서드(C# 8+), interface vs abstract class 선택 기준을 정리합니다.
public interface IDamageable
{
void TakeDamage(int amount);
int Health { get; }
}
public class Enemy : IDamageable
{
public int Health { get; private set; } = 100;
public void TakeDamage(int amount) => Health -= amount;
}
// 인터페이스 타입으로 다루기
void Hit(IDamageable target, int dmg) => target.TakeDamage(dmg);
Hit(new Enemy(), 10); // Enemy를 IDamageable로 취급enum의 기반 타입, `[Flags]` 비트 플래그, `Enum.Parse/TryParse`, int ↔ enum 변환, switch expression과의 결합 패턴을 정리합니다.
public enum GameState
{
Idle, // 0
Playing, // 1
Paused, // 2
GameOver // 3
}
GameState state = GameState.Playing;
string label = state switch
{
GameState.Playing => "진행 중",
GameState.Paused => "일시정지",
GameState.GameOver => "종료",
_ => "대기"
};record가 컴파일러에서 어떤 코드를 자동 생성하는지, record class·record struct·class·struct의 선택 기준, primary constructor와 `init` setter의 의미를 정리합니다.
// positional record — 한 줄 선언
public record User(string Name, int Level);
User mina = new("Mina", 5);
User mina2 = new("Mina", 5);
bool equal = mina == mina2; // true — 값 비교
User senior = mina with { Level = 6 }; // 일부만 바꾼 복사본
Console.WriteLine(mina); // User { Name = Mina, Level = 5 }`public`, `private`, `protected`, `internal`, `protected internal`, `private protected`의 어셈블리·상속 경계별 접근 범위와 기본값 규칙을 정리합니다.
public class Player
{
public string Name { get; private set; } // 읽기 공개, 쓰기 내부
private int _score; // 클래스 내부만
protected int Level; // 파생 클래스까지
internal string Region { get; set; } // 같은 어셈블리
}`virtual/override`, `abstract class`, `sealed`, `base()` 호출 순서, 그리고 상속보다 합성이 나은 상황의 판단 기준을 정리합니다.
public abstract class Shape
{
public string Color { get; set; } = "black";
public abstract double Area(); // 반드시 재정의해야 함
public virtual string Describe() // 선택적으로 재정의 가능
=> $"{Color} shape, area={Area():F2}";
}
public class Circle : Shape
{
public double Radius { get; }
public Circle(double radius) => Radius = radius;
public override double Area() => Math.PI * Radius * Radius;
}값 타입 `struct`의 복사 의미론, `readonly struct`, `ref struct`, boxing/unboxing 비용, struct vs class vs record 선택 기준을 정리합니다.
public readonly struct Point
{
public double X { get; init; }
public double Y { get; init; }
public double DistanceTo(Point other)
{
double dx = X - other.X;
double dy = Y - other.Y;
return Math.Sqrt(dx * dx + dy * dy);
}
}
Point a = new Point { X = 0, Y = 0 };
Point b = new Point { X = 3, Y = 4 };
double d = a.DistanceTo(b); // 5.0record의 `Equals`/`==`가 컴파일러에서 어떻게 생성되는지, `EqualityContract`, `with` 표현식이 내부적으로 `<Clone>$`를 사용하는 방식, 컬렉션 멤버의 얕은 복사 함정을 정리합니다.
public record User(string Name, int Level);
User first = new("Mina", 5);
User second = new("Mina", 5);
User third = first with { Level = 6 };
bool equal = first == second; // true — 값 비교
bool diff = first == third; // false — Level이 다름
Console.WriteLine(first); // User { Name = Mina, Level = 5 }C# 12에서 도입된 primary constructor의 선언 문법과 파라미터 스코프를 이해하고, 기존 생성자 보일러플레이트를 줄이는 원리, record와의 차이, init-only setter 및 required members와의 조합까지 정리합니다.
// class에 primary constructor 적용 (C# 12)
public class UserService(ILogger<UserService> logger, IUserRepository repo)
{
// 파라미터가 클래스 전체 스코프에서 사용 가능
public async Task<User?> FindAsync(int id)
{
logger.LogInformation("Finding user {Id}", id);
return await repo.FindByIdAsync(id);
}
}
// struct에도 동일하게 적용 가능
public struct Point(double x, double y)
{
public double X { get; } = x;
public double Y { get; } = y;
public double Distance => Math.Sqrt(x * x + y * y);
}9 cards
고정 길이 배열의 메모리 구조, `List<T>`의 내부 동적 배열, 다차원 배열, 두 타입의 선택 기준과 변환 방법을 정리합니다.
// 배열 — 고정 길이
int[] scores = { 85, 90, 78 };
string[] slots = new string[3]; // 초기값 null
int first = scores[0]; // 인덱스 접근
// List<T> — 가변 길이
var names = new List<string> { "Mina", "Jin" };
names.Add("Sol");
names.Remove("Jin");
int count = names.Count;`Dictionary<TKey, TValue>`의 O(1) 조회 원리, 안전한 읽기 패턴, 순회 방법, `GetValueOrDefault`, 스레드 안전이 필요한 경우의 대안을 정리합니다.
var scores = new Dictionary<string, int>
{
["Mina"] = 1200,
["Jin"] = 980,
};
// 안전한 읽기
if (scores.TryGetValue("Mina", out int score))
Console.WriteLine(score);
// 기본값 반환 (키 없으면 0)
int rating = scores.GetValueOrDefault("Sora", 0);컬렉션 초기화식, target-typed `new()`, C# 12 컬렉션 식(`[]`)이 컴파일러에서 어떻게 변환되는지와 각각의 사용 기준을 정리합니다.
// 컬렉션 초기화식
var numbers = new List<int> { 1, 2, 3, 4 };
var scores = new Dictionary<string, int>
{
["Mina"] = 1200,
["Jin"] = 980,
};
// C# 9+ target-typed new
List<int> primes = new() { 2, 3, 5, 7 };
// C# 12+ 컬렉션 식
int[] arr = [1, 2, 3];
List<int> list = [1, 2, 3];LINQ가 extension method로 구현되는 방식, 지연 실행(deferred execution)과 즉시 실행의 차이, `Where`/`Select`/`OrderBy`/`Any`/`First` 핵심 연산자를 정리합니다.
List<string> highScores = players
.Where(p => p.Score >= 1000) // 필터링
.OrderByDescending(p => p.Score) // 정렬
.Select(p => $"{p.Name}: {p.Score}") // 변환
.ToList(); // 즉시 실행 + List로 확정`HashSet<T>`의 O(1) 포함 검사 원리, 집합 연산(`UnionWith`, `IntersectWith`, `ExceptWith`), `List<T>`·`SortedSet<T>`와의 선택 기준을 정리합니다.
var tags = new HashSet<string> { "csharp", "dotnet", "linq" };
tags.Add("async");
tags.Add("csharp"); // 이미 존재 → 무시, 중복 없음
bool has = tags.Contains("linq"); // O(1)
Console.WriteLine(tags.Count); // 4`IEnumerable<T>`의 지연 실행이 반복 열거 시 재계산되는 이유, `ToList()`/`ToArray()`로 스냅샷을 만드는 기준, `yield return`으로 직접 지연 시퀀스를 만드는 방법을 정리합니다.
// IEnumerable — 지연 실행, 열거할 때 계산
IEnumerable<Player> query = players
.Where(p => p.Score >= 1000)
.OrderByDescending(p => p.Score);
// List — 지금 계산하고 결과를 메모리에 고정
List<Player> snapshot = query.ToList();
// snapshot은 이후 players가 변해도 영향 없음
players.Clear();
Console.WriteLine(snapshot.Count); // 원래 결과 유지`GroupBy`가 IGrouping 시퀀스를 생성하는 방식, `Join`의 내부 해시 테이블 동작, `SelectMany`로 중첩을 평탄화하는 패턴, projection에서 익명 타입과 record를 선택하는 기준을 정리합니다.
// Join + GroupBy + projection
var result = players
.Join(
teams,
player => player.TeamId,
team => team.Id,
(player, team) => new { player.Name, TeamName = team.Name })
.GroupBy(x => x.TeamName)
.Select(group => new
{
Team = group.Key,
Members = group.Select(x => x.Name).ToList(),
Count = group.Count()
});Queue<T>(FIFO)와 Stack<T>(LIFO)의 내부 구조, Enqueue/Dequeue/Push/Pop/Peek 패턴, ConcurrentQueue와 PriorityQueue<T> 사용 기준을 정리합니다.
// Queue<T> — FIFO (선입선출)
var queue = new Queue<string>();
queue.Enqueue("첫 번째");
queue.Enqueue("두 번째");
string first = queue.Dequeue(); // "첫 번째"
string peek = queue.Peek(); // "두 번째" (꺼내지 않음)
// Stack<T> — LIFO (후입선출)
var stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
int top = stack.Pop(); // 2
int look = stack.Peek(); // 1
// 안전한 꺼내기
if (queue.TryDequeue(out string? item)) { /* ... */ }
if (stack.TryPop(out int value)) { /* ... */ }C# 12에서 도입된 컬렉션 식 `[...]` 리터럴로 List, Array, Span, IEnumerable을 통일된 문법으로 초기화하는 방법, spread 연산자 `..`를 이용한 컬렉션 병합 패턴, 타입 추론 규칙과 var 제약까지 정리합니다.
// 동일한 문법으로 다양한 컬렉션 타입 초기화
int[] arr = [1, 2, 3];
List<int> list = [1, 2, 3];
Span<int> span = [1, 2, 3];
IEnumerable<int> seq = [1, 2, 3];
// spread 연산자 .. 로 컬렉션 병합
int[] first = [1, 2, 3];
int[] second = [4, 5, 6];
int[] merged = [..first, ..second, 7]; // [1, 2, 3, 4, 5, 6, 7]
// 빈 컬렉션
List<string> empty = [];4 cards
`try/catch/finally`의 실행 순서, 예외 계층 구조, `throw` vs `throw ex` 차이, 사용자 정의 예외, 언제 예외를 쓰고 언제 TryParse 패턴을 쓸지 판단 기준을 정리합니다.
try
{
var data = File.ReadAllText(path);
Process(data);
}
catch (FileNotFoundException ex)
{
Console.WriteLine($"파일 없음: {ex.Message}");
}
catch (IOException ex)
{
Console.WriteLine($"IO 오류: {ex.Message}");
throw; // 원래 stack trace 유지하며 재던지기
}
finally
{
Console.WriteLine("항상 실행됨"); // 성공/실패 무관
}`File` 정적 메서드와 `StreamReader/Writer`의 차이, async 파일 IO, `Path` 유틸리티, 인코딩 처리까지 실무에서 필요한 파일 IO 패턴을 정리합니다.
// 경로 조합 (OS 구분자 자동 처리)
string path = Path.Combine("data", "memo.txt");
// 소규모 파일 — File 정적 메서드
File.WriteAllText(path, "안녕하세요", Encoding.UTF8);
string content = File.ReadAllText(path, Encoding.UTF8);
string[] lines = File.ReadAllLines(path, Encoding.UTF8);
// 대용량 파일 — async + StreamReader
await using var reader = new StreamReader(path, Encoding.UTF8);
while (!reader.EndOfStream)
{
string? line = await reader.ReadLineAsync();
// 한 줄씩 처리 — 전체를 메모리에 올리지 않음
}`IDisposable`이 GC와 독립적으로 자원을 즉시 해제하는 이유, `using` 문의 두 형태, `IAsyncDisposable`, 직접 `IDisposable`을 구현하는 방법을 정리합니다.
// using var — 현재 스코프 끝에서 자동 Dispose
using var reader = new StreamReader(path);
string content = reader.ReadToEnd();
// 메서드 끝 or 예외 발생 시 reader.Dispose() 자동 호출
// using 블록 — 블록 종료 시 Dispose
using (var conn = new SqlConnection(connString))
{
conn.Open();
// 블록 끝에 conn.Dispose()
}
// async 자원
await using var stream = new FileStream(path, FileMode.Open);HttpClient를 직접 new하면 발생하는 socket exhaustion 문제와 DNS 갱신 문제를 IHttpClientFactory가 해결하는 원리, DI 등록 패턴, GetFromJsonAsync·PostAsJsonAsync 실용 패턴, timeout과 CancellationToken 결합까지 정리합니다.
// Program.cs — IHttpClientFactory 등록
builder.Services.AddHttpClient("weather", client =>
{
client.BaseAddress = new Uri("https://api.weather.example.com/");
client.DefaultRequestHeaders.Add("Accept", "application/json");
client.Timeout = TimeSpan.FromSeconds(10);
});
// 서비스에서 사용
public class WeatherService(IHttpClientFactory httpFactory)
{
public async Task<WeatherData?> GetAsync(string city, CancellationToken ct)
{
var client = httpFactory.CreateClient("weather");
return await client.GetFromJsonAsync<WeatherData>($"current/{city}", ct);
}
}6 cards
`async/await`가 컴파일러에서 상태 머신으로 변환되는 방식, `Task`/`Task<T>` 반환 타입, `async void` 금지 이유, `ConfigureAwait`와 취소 토큰을 정리합니다.
public async Task<string> LoadDataAsync(HttpClient http)
{
using HttpResponseMessage response = await http.GetAsync("/api/items");
response.EnsureSuccessStatusCode();
return await response.Content.ReadAsStringAsync();
}
// 취소 토큰으로 3초 제한
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
string json = await http.GetStringAsync(url, cts.Token);delegate가 내부적으로 멀티캐스트 델리게이트로 동작하는 방식, `Action`/`Func`와 사용자 정의 delegate의 선택, `event` 키워드가 소유권을 제한하는 이유를 정리합니다.
// delegate — 메서드를 값처럼 전달
Action<string> log = msg => Console.WriteLine(msg);
Func<int, bool> isEven = n => n % 2 == 0;
log("hello");
bool result = isEven(4); // true
// event — publisher/subscriber 패턴
public class Button
{
public event Action? Clicked;
public void RaiseClick() => Clicked?.Invoke();
}
var btn = new Button();
btn.Clicked += () => Console.WriteLine("clicked");
btn.RaiseClick();event가 publisher에서 subscriber로 어떻게 전달되는지, 구독 등록·발생·해제의 흐름을 한 장으로 확인하는 시각화 카드입니다.
// 1. 구독 등록
publisher.Changed += OnChanged;
// 2. publisher 내부에서 발생
Changed?.Invoke(this, EventArgs.Empty);
// 3. 더 이상 필요 없을 때 해제
publisher.Changed -= OnChanged;`Task.WhenAll`이 task를 동시에 시작하는 방식, 순차 await와의 차이, 예외 집계 동작, `WhenAny`와의 비교, 동시성 제한 패턴을 정리합니다.
// task를 먼저 시작해두고 한 번에 기다림
Task<User> userTask = LoadUserAsync();
Task<Order[]> orderTask = LoadOrdersAsync();
await Task.WhenAll(userTask, orderTask); // 두 작업이 동시에 진행됨
User user = await userTask; // 이미 완료됨 — 바로 반환
Order[] orders = await orderTask;
// 컬렉션 버전
string[] results = await Task.WhenAll(
urls.Select(url => http.GetStringAsync(url)));공유 상태에서 발생하는 레이스 컨디션, lock 키워드의 동작 원리(Monitor.Enter/Exit), Interlocked 원자 연산, volatile의 역할을 정리합니다.
private readonly object _syncRoot = new();
private int _count = 0;
// lock으로 임계 구역 보호
public void Increment()
{
lock (_syncRoot)
{
_count++;
}
}
// 단순 카운터는 Interlocked이 더 가볍다
private int _atomicCount = 0;
public void AtomicIncrement()
=> Interlocked.Increment(ref _atomicCount);
// async 환경 — lock 대신 SemaphoreSlim
private readonly SemaphoreSlim _sem = new(1, 1);
public async Task SafeWriteAsync()
{
await _sem.WaitAsync();
try { /* 작업 */ }
finally { _sem.Release(); }
}CancellationTokenSource로 취소 신호를 만들고 async 메서드 체인에 전달하는 협력 취소 모델, LinkedTokenSource로 여러 취소 신호를 결합하는 패턴, ThrowIfCancellationRequested와 IsCancellationRequested의 선택 기준을 정리합니다.
// CancellationTokenSource 생성 및 취소
using var cts = new CancellationTokenSource();
// 3초 후 자동 취소
cts.CancelAfter(TimeSpan.FromSeconds(3));
try
{
await DoWorkAsync(cts.Token);
}
catch (OperationCanceledException)
{
Console.WriteLine("작업이 취소되었습니다.");
}
async Task DoWorkAsync(CancellationToken ct)
{
for (int i = 0; i < 10; i++)
{
ct.ThrowIfCancellationRequested(); // 취소 신호 확인
await Task.Delay(500, ct); // Delay도 취소 인식
Console.WriteLine($"Step {i}");
}
}12 cards
`?.`, `?[]`, `??`, `??=`가 각각 어떻게 동작하는지, null 체크 체인이 컴파일러에서 어떻게 변환되는지, `default`와의 차이를 정리합니다.
// 안전한 속성 접근 체인
string displayName = user?.Profile?.Nickname ?? "Guest";
// 안전한 인덱서 접근
char? first = text?[0];
// null일 때만 초기화
settings.Theme ??= "light";
// 이벤트 안전 호출
OnChanged?.Invoke(this, EventArgs.Empty);람다 식의 문법, `Func`·`Action` 타입, 클로저가 변수를 캡처하는 방식과 수명 위험, 식 본문 멤버(`=>`)를 정리합니다.
// 람다 식 기본 형태
Func<int, int> square = x => x * x;
Func<int, int, int> add = (x, y) => x + y;
Action<string> print = msg => Console.WriteLine(msg);
// LINQ와 결합
var evens = numbers.Where(n => n % 2 == 0).ToList();제네릭이 컴파일러에서 타입별로 코드를 생성하는 방식, `where` 제약의 종류, 제네릭 클래스 vs 메서드, `object` 기반 API와의 boxing 비용 비교를 정리합니다.
// 제네릭 클래스
public class Box<T>
{
public T Value { get; set; }
public Box(T value) => Value = value;
}
Box<int> numBox = new(42);
Box<string> strBox = new("hello");
// 제네릭 메서드
T Identity<T>(T value) => value;
int n = Identity(10); // T = int 추론
string s = Identity("hi"); // T = string 추론ValueTuple과 Tuple의 차이, 이름 있는 튜플, 커스텀 `Deconstruct`, 튜플·record·클래스 중 무엇을 선택할지 기준을 정리합니다.
// 이름 있는 튜플 반환
(string Name, int Age) GetUser()
=> ("Mina", 26);
var user = GetUser();
Console.WriteLine(user.Name); // "Mina"
// 구조 분해 (deconstruction)
var (name, age) = GetUser();
Console.WriteLine($"{name} / {age}");extension method가 컴파일러에서 정적 메서드 호출로 변환되는 방식, LINQ가 extension method 기반인 이유, 우선순위 규칙과 남용 시 문제를 정리합니다.
public static class StringExtensions
{
public static bool IsBlank(this string value)
=> string.IsNullOrWhiteSpace(value);
public static string Truncate(this string value, int maxLength)
=> value.Length <= maxLength ? value : value[..maxLength] + "…";
}
// 마치 인스턴스 메서드처럼 호출
bool empty = " ".IsBlank(); // true
string short = "Hello, World!".Truncate(5); // "Hello…"`#nullable enable`이 컴파일러 분석을 어떻게 바꾸는지, `string` vs `string?`의 의미, null-forgiving 연산자 `!`, 런타임 null 검사와의 조합을 정리합니다.
#nullable enable
string name = "Mina"; // null 아님 — 컴파일러가 null 대입 경고
string? nickname = null; // null 허용
// null 체크 후 사용
if (nickname is not null)
Console.WriteLine(nickname.Length); // 경고 없음 — 컴파일러가 non-null로 추론
// 런타임 검사 (공개 API 경계)
ArgumentNullException.ThrowIfNull(name);값 타입이 스택에, 참조 타입이 힙에 저장되는 방식, 대입 시 복사 vs 참조 공유, boxing/unboxing 비용, string의 특수한 위치를 정리합니다.
// 값 타입 — 대입 시 복사
int a = 10;
int b = a;
b = 20;
Console.WriteLine(a); // 10 — a는 변하지 않음
// 참조 타입 — 대입 시 참조 공유
var first = new Player("Mina");
var second = first; // 같은 객체를 가리킴
second.Name = "Jin";
Console.WriteLine(first.Name); // "Jin" — first도 바뀜!`ref`·`out`·`in`이 내부적으로 포인터처럼 동작하는 방식, `in`의 방어적 복사, ref return·ref local, 그리고 튜플 반환과의 선택 기준을 정리합니다.
// ref — 호출자 변수를 직접 수정
void Increment(ref int value) => value++;
int score = 10;
Increment(ref score); // score == 11
// out — 메서드에서 추가 결과 반환
bool TryDivide(int left, int right, out int result)
{
if (right == 0) { result = 0; return false; }
result = left / right;
return true;
}
if (TryDivide(20, 4, out int quotient))
Console.WriteLine(quotient); // 5
// in — 읽기 전용 참조 (복사 방지)
void PrintArea(in Rectangle rect)
=> Console.WriteLine(rect.Width * rect.Height);`Span<T>`가 `ref struct`인 이유와 스택 제약, `Memory<T>`가 힙에 저장 가능한 이유, `ArrayPool<T>`로 배열 재사용, 실제 성능 개선 패턴을 정리합니다.
// ReadOnlySpan<char> — 문자열 일부를 새 할당 없이 참조
ReadOnlySpan<char> name = "RefDock".AsSpan();
ReadOnlySpan<char> first = name[..3]; // "Ref" — 복사 없음
// 배열의 일부를 span으로
int[] arr = { 1, 2, 3, 4, 5 };
Span<int> slice = arr.AsSpan(1, 3); // { 2, 3, 4 }
slice[0] = 99; // arr[1] == 99 — 원본 수정
// Span 기반 파싱 — Substring() 없이
ReadOnlySpan<char> line = "key=value".AsSpan();
int eq = line.IndexOf('=');
ReadOnlySpan<char> key = line[..eq]; // "key"
ReadOnlySpan<char> value = line[(eq + 1)..]; // "value".NET DI 컨테이너가 서비스를 생성·관리하는 방식, singleton/scoped/transient 수명의 차이, `IOptions<T>` vs `IOptionsSnapshot<T>` vs `IOptionsMonitor<T>` 선택 기준을 정리합니다.
// 서비스 등록
builder.Services.AddSingleton<ICache, MemoryCache>();
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddTransient<IEmailSender, SmtpEmailSender>();
// options pattern 등록
builder.Services.Configure<AppOptions>(
builder.Configuration.GetSection("App"));
// 생성자 주입
public class UserService(ICache cache, IOptions<AppOptions> options)
{
private readonly AppOptions _opts = options.Value;
}Action<T>, Func<T, TResult>, Predicate<T>의 시그니처 규칙, 람다·메서드 그룹 대입, 콜백·전략 패턴 구현에서의 활용을 정리합니다.
// 반환값 없음
Action<string> log = msg => Console.WriteLine($"[LOG] {msg}");
log("시작");
// 반환값 있음 — 마지막 타입이 반환형
Func<int, int, int> add = (a, b) => a + b;
int result = add(3, 4); // 7
// Predicate<T> — bool 반환 특화
Predicate<int> isEven = n => n % 2 == 0;
var evens = new List<int> { 1, 2, 3, 4 }.FindAll(isEven);
// 콜백 파라미터
void Process(IEnumerable<int> items, Action<int> onEach)
{
foreach (var item in items) onEach(item);
}내장 어트리뷰트([Obsolete], [Flags], [CallerMemberName])의 동작 원리, 커스텀 어트리뷰트 선언과 리플렉션으로 읽는 패턴, AttributeTargets 제한 방법을 정리합니다.
// 내장 어트리뷰트
[Obsolete("V2 API를 사용하세요", error: false)]
public void OldMethod() { }
// 커스텀 어트리뷰트 선언
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class AuditAttribute : Attribute
{
public string Reason { get; }
public AuditAttribute(string reason) => Reason = reason;
}
// 적용
[Audit("결제 처리 — 감사 로그 필수")]
public void ProcessPayment() { }
// 리플렉션으로 읽기
var attr = typeof(MyClass)
.GetMethod("ProcessPayment")
?.GetCustomAttribute<AuditAttribute>();
Console.WriteLine(attr?.Reason);