Category
Preparing references and filters for this topic. 이 주제의 레퍼런스와 필터를 준비하고 있습니다.
변수 선언·초기화, 정수·실수·문자·논리·문자열 literal, `var`·`dynamic`, numeric conversion과 overflow 경계를 정리합니다.
int count = 3;
string name = "Mina";
bool ready = true;
char grade = 'A';
long distance = 384_400_000L;
float gravity = 9.81f;
decimal price = 19.99m;
int hex = 0x2A;
int binary = 0b_0010_1010;
var labels = new List<string>(); // List<string>로 고정이름을 해석하는 `using` directive와 namespace 선언, alias·static·global using의 범위와 충돌 해결을 정리합니다.
using System.Text;
using JsonSerializer = System.Text.Json.JsonSerializer;
using static System.Math;
namespace RefDock.Services;
public sealed class SlugService
{
public string Serialize(object value) => JsonSerializer.Serialize(value);
public double Root(double value) => Sqrt(value);
}산술·비교·대입·논리·비트·shift·조건 연산자의 평가 순서, short-circuit, overflow와 equality 경계를 정리합니다.
int quotient = 10 / 3; // 3
bool passed = score >= 60;
bool canEnter = hasTicket && IsOpen(); // 왼쪽 false면 IsOpen 미실행
bool bothEvaluated = hasTicket & IsOpen(); // 양쪽 실행
const int Read = 1;
const int Write = 2;
int flags = Read | Write;
string label = isAdmin ? "admin" : "user";매개변수 없는·있는 메서드, 반환·식 본문, optional·named·params argument, overload와 local function의 호출 계약을 정리합니다.
void Log() => Console.WriteLine("saved"); // 매개변수·반환값 없음
int GetCount() => 3; // 매개변수 없음, 값 반환
int Add(int left, int right) => left + right; // 필수 매개변수
void Create(string name, int level = 1) { }
int Sum(params int[] values) => values.Sum();
Log();
int count = GetCount();
Create("Mina", level: 5);
int total = Sum(); // 0개
total = Sum(1, 2, 3); // 개별 인자
total = Sum([1, 2, 3]); // 배열불변 `string`의 기본 조작, null·빈 값 처리, 비교 규칙, 분리·결합과 Unicode 길이의 경계를 정리합니다.
string raw = " Mina, Jin, ";
string[] names = raw
.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
bool sameUser = string.Equals(
names[0], "mina", StringComparison.OrdinalIgnoreCase);보간, 축자, 원시 문자열 리터럴을 선택하는 기준과 정렬·서식·문화권 처리 규칙을 정리합니다.
string name = "Mina";
decimal rate = 0.856m;
string label = $"{name,-8} {rate:P1}"; // "Mina 85.6%"
string path = @"C:\logs\app.txt";
string json = """
{ "name": "Mina" }
""";`Parse`·`TryParse`·exact parsing의 성공·실패 contract, `NumberStyles`·`IFormatProvider`, default output과 span parsing 선택을 정리합니다.
int value = int.Parse("42");
if (int.TryParse(input, out int parsed))
{
Process(parsed);
}
bool valid = int.TryParse(input, out _);DateTime, DateOnly, TimeSpan의 생성·연산·포맷, DateTimeOffset의 타임존 처리, 안전한 파싱 패턴을 정리합니다.
DateTimeOffset recordedAt = DateTimeOffset.UtcNow;
DateOnly birthday = new DateOnly(2026, 3, 25);
TimeOnly openingTime = new TimeOnly(9, 30);
// API/저장소: round-trip 가능한 UTC 시점
string payload = recordedAt.ToString("O", CultureInfo.InvariantCulture);
DateTimeOffset parsed = DateTimeOffset.ParseExact(
payload, "O", CultureInfo.InvariantCulture, DateTimeStyles.None);
// 화면 표시: 선택한 사용자의 time zone으로 변환한 뒤 형식화
TimeZoneInfo displayZone = TimeZoneInfo.Utc; // 실제 앱에서는 사용자 설정으로 선택
DateTimeOffset local = TimeZoneInfo.ConvertTime(parsed, displayZone);반복 텍스트 조립에 쓰는 `StringBuilder`의 Append 계열, 용량, 변경 API와 수명·동시성 경계를 정리합니다.
var text = new StringBuilder(capacity: 256);
text.Append("name: ").AppendLine("Mina");
text.Append("scores: ").AppendJoin(", ", [90, 85, 100]);
string result = text.ToString();`nameof`의 source name, `typeof`·`GetType`의 metadata와 runtime type, `sizeof`·`Unsafe.SizeOf`·`Marshal.SizeOf`의 크기 계약을 정리합니다.
ArgumentNullException.ThrowIfNull(name, nameof(name));
Type declared = typeof(IEnumerable<string>);
object value = "Mina";
Type runtime = value.GetType();
int intBytes = sizeof(int); // 4C# 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..]; // "World!"`if/else`, 삼항 연산자, 가드 클로즈 패턴의 차이와 단락 평가, 조건문 중첩을 줄이는 실전 구조를 정리합니다.
if (score >= 90)
grade = "A";
else if (score >= 80)
grade = "B";
else
grade = "C";
// 단순 이진 선택은 삼항 연산자가 더 짧다
string label = isActive ? "활성" : "비활성";
// 실패를 먼저 끝내고, &&로 오른쪽 호출을 안전하게 묶음
if (order is null) return;
bool canStart = isReady && TryStart();`switch statement`와 `switch expression`의 value·flow 차이, pattern·`when`·null arm·exhaustiveness와 enum versioning 선택을 정리합니다.
string label = state switch
{
GameState.Ready => "ready",
GameState.Playing => "playing",
null => "missing",
_ => throw new ArgumentOutOfRangeException(nameof(state)),
};
switch (command)
{
case "save": Save(); break;
case "quit": Close(); break;
}`for`·`foreach`·`while`·`do`의 실행 횟수와 선택, `break`·`continue`, collection 수정과 enumeration contract를 정리합니다.
for (int index = 0; index < items.Count; index++) { }
foreach (string name in names) { }
while (queue.TryDequeue(out var item)) { Process(item); }
do { input = Read(); } while (string.IsNullOrWhiteSpace(input));constant·declaration·type·relational·property·var·discard pattern과 logical combination, `when` guard와 arm 순서의 선택 기준을 정리합니다.
bool isReady = value is true; // constant
bool valid = score is >= 0 and <= 100; // relational + logical
if (input is string text and { Length: > 0 }) // type + property
{
Console.WriteLine(text);
}
if (candidate is null) { }`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}, 이후 더 있음"
};클래스가 참조 타입인 이유, 필드·프로퍼티·메서드의 역할, 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() : this("Guest", 1) { }
public Player(string name) : this(name, 1) { }
public Player(string name, int level)
{
Name = name;
Level = level;
}
}
var guest = new Player();
var beginner = new Player("Mina");
var veteran = new Player("Jin", 50);자동·계산 프로퍼티, `get/set/init/required`, validation과 `SetsRequiredMembers` 경계를 기준으로 상태 API를 설계하는 방법을 정리합니다.
public sealed class Player
{
public required string Name { get; init; }
public int Score { get; private set; }
public bool IsVeteran => Score >= 1_000;
public void AddScore(int amount) => Score += amount;
}
var player = new Player { Name = "Mina" };
player.AddScore(1_000);`interface` 계약, 명시적 구현, 기본 인터페이스 멤버와 static abstract member, 추상 클래스·합성과의 선택 기준을 정리합니다.
public interface INotifier
{
void Notify(string message);
}
public sealed class ConsoleNotifier : INotifier
{
public void Notify(string message) => Console.WriteLine(message);
}
static void Send(INotifier notifier) => notifier.Notify("saved");이름 있는 정수 값인 enum의 0값·기반 타입·flags 조합·문자열과 외부 값 검증 규칙을 정리합니다.
public enum JobState : byte
{
Unknown = 0,
Queued = 1,
Running = 2,
Done = 3,
}
[Flags]
public enum Access : byte
{
None = 0,
Read = 1,
Write = 2,
Delete = 4,
}record class·record struct의 선언 형태, 값 기반 equality, `with` 복사와 mutable member 경계를 기준으로 class·struct 선택을 정리합니다.
public record User(string Name, int Level);
User mina = new("Mina", 5);
User senior = mina with { Level = 6 };
Console.WriteLine(mina == new User("Mina", 5)); // True`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(string color)
{
public string Color { get; } = color;
public abstract double Area();
public virtual string Describe() => $"{Color}, {Area():F2}";
}
public sealed class Circle(double radius) : Shape("blue")
{
public override double Area() => Math.PI * radius * radius;
}`struct`의 값 복사, `readonly struct`, `ref struct`, default 초기화와 boxing 경계를 기준으로 class·record와의 선택을 정리합니다.
public readonly struct Money(decimal amount)
{
public decimal Amount { get; } = amount;
public Money Add(Money other) => new(Amount + other.Amount);
}
Money subtotal = new(10m);
Money total = subtotal.Add(new Money(5m));record class·record struct의 값 기반 equality, `with`의 얕은 복사, 상속·hash key·가변 멤버 경계를 정리합니다.
public record User(string Name, int Level);
User first = new("Mina", 5);
User second = new("Mina", 5);
User senior = first with { Level = 6 };
Console.WriteLine(first == second); // True
Console.WriteLine(first == senior); // FalseC# 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);
}고정 길이 배열의 메모리 구조, `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;
int capacity = names.EnsureCapacity(16); // 앞으로 16개까지 담을 공간 확보키 하나에 값 하나를 연결하는 `Dictionary<TKey, TValue>`의 읽기·추가·갱신 API와 키 비교 규칙을 정리합니다.
var scores = new Dictionary<string, int>
{
["Mina"] = 1200,
};
if (scores.TryGetValue("Mina", out int score))
Console.WriteLine(score);
scores["Mina"] = 1250; // 있으면 갱신, 없으면 추가
bool added = scores.TryAdd("Jin", 980); // 없을 때만 추가
bool removed = scores.Remove("Mina");컬렉션 초기화식, target-typed `new()`, C# 12 컬렉션 식(`[]`)이 컴파일러에서 어떻게 변환되는지와 각각의 사용 기준을 정리합니다.
// object initializer
var player = new Player { Name = "Mina", Level = 1 };
// 컬렉션 초기화식
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로 확정
var optionalTop = players.FirstOrDefault(p => p.Score >= 1000); // 없으면 null
var onlyMina = players.Single(p => p.Name == "Mina"); // 정확히 하나여야 함중복 없는 원소 집합을 다루는 `HashSet<T>`의 포함 검사, 집합 연산, 비교 규칙을 정리합니다.
var visited = new HashSet<int>();
if (visited.Add(42))
{
// 42를 처음 방문했을 때만 실행
}
bool seen = visited.Contains(42);
bool removed = visited.Remove(42);`IEnumerable<T>`가 뜻하는 열거 계약과 `List<T>` 스냅샷, LINQ 지연 실행, `ToList()`을 선택하는 기준을 정리합니다.
var players = new List<Player> { new("Mina", 1200), new("Jin", 900) };
IEnumerable<Player> query = players.Where(p => p.Score >= 1000);
List<Player> snapshot = query.ToList();
players.Clear();
Console.WriteLine(snapshot.Count); // 1: 원소 목록은 유지LINQ에서 그룹·조인·평탄화·projection이 만드는 결과 형태와 materialization 지점을 정리합니다.
var byTeam = players.GroupBy(player => player.TeamId);
var playerTeams = players.Join(
teams,
player => player.TeamId,
team => team.Id,
(player, team) => new PlayerTeam(player.Name, team.Name));
var memberNames = teams.SelectMany(team => team.Members, (team, member) =>
new { Team = team.Name, Member = member.Name });FIFO·LIFO·우선순위 큐를 고르는 기준과 안전하게 꺼내는 API, 동시성 경계를 정리합니다.
var jobs = new Queue<string>();
jobs.Enqueue("import");
if (jobs.TryDequeue(out string? job))
Process(job);
var undo = new Stack<string>();
undo.Push("rename");
if (undo.TryPop(out string? action))
Undo(action);
var scheduled = new PriorityQueue<string, int>();
scheduled.Enqueue("urgent", priority: 0);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 = [];`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);
// 대용량 파일 — 한 줄씩 비동기 처리
using var reader = new StreamReader(path, Encoding.UTF8);
string? line;
while ((line = await reader.ReadLineAsync()) is not null)
{
// 한 줄씩 처리 — 전체를 메모리에 올리지 않음
}결정적으로 자원을 정리하는 `IDisposable`과 `IAsyncDisposable`, using의 수명 범위, 소유권과 직접 구현 기준을 정리합니다.
using (var reader = File.OpenText(path))
{
string text = reader.ReadToEnd(); // 블록을 나갈 때 Dispose
}
using var writer = File.CreateText(outputPath); // 현재 scope 끝에서 Dispose
await using var stream = File.OpenRead(path); // IAsyncDisposable: scope 끝에서 DisposeAsyncHttpClient를 직접 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.Accept.ParseAdd("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);
}
}`async/await`가 컴파일러에서 상태 머신으로 변환되는 방식, `Task`/`Task<T>` 반환 타입, `async void` 금지 이유, `ConfigureAwait`와 취소 토큰을 정리합니다.
public static async Task<string> LoadDataAsync(
HttpClient http,
string url,
CancellationToken ct)
{
using HttpResponseMessage response = await http.GetAsync(url, ct);
response.EnsureSuccessStatusCode();
return await response.Content.ReadAsStringAsync(ct);
}
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
string json = await LoadDataAsync(http, url, cts.Token);`Action`·`Func`·사용자 정의 delegate와 `event`의 소유권, multicast 예외 정책, 구독 수명과 async 알림 계약을 정리합니다.
public sealed class Counter
{
private int _value;
public event EventHandler<CountChangedEventArgs>? CountChanged;
public void Increment()
{
_value++;
CountChanged?.Invoke(this, new CountChangedEventArgs(_value));
}
}
public sealed class CountChangedEventArgs(int value) : EventArgs
{
public int Value { get; } = value;
}event의 구독·발생·동기 handler 실행·구독 해제 흐름을 한 장에서 확인합니다.
publisher.Changed += OnChanged; // 1. 구독
publisher.Raise(); // 2. publisher 내부에서 발생
publisher.Changed -= OnChanged; // 3. 종료 시 해제`Task.WhenAll`이 task를 동시에 시작하는 방식, 순차 await와의 차이, 예외 집계 동작, `WhenAny`와의 비교, 동시성 제한 패턴을 정리합니다.
// task를 먼저 시작해두고 한 번에 기다림
Task<User> userTask = LoadUserAsync();
Task<Order[]> orderTask = LoadOrdersAsync();
await Task.WhenAll(userTask, orderTask); // 이미 시작한 두 task가 모두 끝날 때까지 대기
User user = await userTask; // 이미 완료됨 — 바로 반환
Order[] orders = await orderTask;
// 컬렉션 버전
string[] results = await Task.WhenAll(
urls.Select(url => http.GetStringAsync(url)));공유 상태의 race condition을 막는 `lock`, `Interlocked`, `Volatile`, async 임계 구역의 선택과 실패 경계를 정리합니다.
private readonly System.Threading.Lock _gate = new(); // .NET 9 / C# 13+
private int _count;
public void AddOne()
{
lock (_gate)
_count++;
}
public int AddOneAtomically() => Interlocked.Increment(ref _count);CancellationTokenSource로 취소 신호를 만들고 async 메서드 체인에 전달하는 협력 취소 모델, LinkedTokenSource로 여러 취소 신호를 결합하는 패턴, ThrowIfCancellationRequested와 IsCancellationRequested의 선택 기준을 정리합니다.
using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
try
{
await DoWorkAsync(timeoutCts.Token);
}
catch (OperationCanceledException) when (timeoutCts.IsCancellationRequested)
{
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}");
}
}`?.`·`?[]`·`??`·`??=`의 conditional evaluation, null 외 예외 범위, fallback·초기화·동시성 경계를 정리합니다.
string displayName = user?.Profile?.Nickname ?? "Guest";
char? first = text?[0];
cache ??= new Dictionary<string, string>();
OnChanged?.Invoke(this, EventArgs.Empty);람다의 매개변수·본문 형태, delegate·expression tree 변환, 클로저와 async callback의 수명·완료 계약을 정리합니다.
Action line = () => Console.WriteLine();
Func<int, int> square = x => x * x;
Func<int, int, int> add = (left, right) => left + right;
Func<int, string> sign = value =>
{
return value >= 0 ? "non-negative" : "negative";
};제네릭 type parameter와 type inference, `where` 제약의 전체 문법, variance와 boxing 경계를 기준으로 재사용 가능한 API를 정리합니다.
public sealed class Box<T>(T value)
{
public T Value { get; } = value;
}
static T Max<T>(T left, T right) where T : IComparable<T>
=> left.CompareTo(right) >= 0 ? left : right;
int largest = Max(3, 5); // T는 호출 인자에서 추론`ValueTuple`·`Tuple<T...>`의 value/reference semantics, element name, deconstruction·discard와 tuple·record의 API 선택을 정리합니다.
static (string Name, int Age) GetUser() => ("Mina", 26);
var user = GetUser();
Console.WriteLine(user.Name);
var (name, age) = GetUser();
(_, int onlyAge) = GetUser();기존 타입에 호출 문법을 추가하는 extension method와 C# 14 extension block의 선언·바인딩·API 설계 경계를 정리합니다.
public static class StringExtensions
{
public static bool IsBlank(this string? value) =>
string.IsNullOrWhiteSpace(value);
}
string? name = null;
bool blank = name.IsBlank();`string`·`string?` annotation, null-state analysis, API contract attribute, runtime guard와 null-forgiving의 경계를 정리합니다.
#nullable enable
string required = "Mina";
string? optional = GetNickname();
if (optional is not null)
{
Console.WriteLine(optional.Length); // 이 block에서는 not-null
}값·참조 타입 변수의 복사와 identity, nullable value, boxing, 값 안의 참조 멤버를 기준으로 타입 선택을 정리합니다.
var left = new Point(1, 2);
var right = left;
right = right with { X = 10 }; // left는 (1, 2) 그대로
var first = new Player("Mina");
var second = first;
second.Name = "Jin"; // first.Name도 "Jin"`ref/out/in/ref readonly/scoped`의 alias·초기화·쓰기·escape 계약, ref return과 tuple/Result 선택 기준을 정리합니다.
static void Increment(ref int value) => value++;
static bool TryDivide(int left, int right, out int quotient)
{
quotient = right == 0 ? 0 : left / right;
return right != 0;
}
static int Area(in Rectangle rectangle) => rectangle.Width * rectangle.Height;
int score = 10;
Increment(ref score);
if (TryDivide(20, 4, out int result)) Console.WriteLine(result);동기 슬라이스에 쓰는 `Span<T>`, async·보관 경계의 `Memory<T>`, buffer lease와 `ArrayPool<T>` 반납 규칙을 정리합니다.
ReadOnlySpan<char> line = "port=8080";
ReadOnlySpan<char> value = line[(line.IndexOf('=') + 1)..];
int port = int.Parse(value);
byte[] bytes = new byte[1024];
Span<byte> header = bytes.AsSpan(0, 16);
Memory<byte> pendingRead = bytes.AsMemory();.NET DI의 singleton·scoped·transient 수명과 strongly typed options의 바인딩·검증·갱신 표면을 정리합니다.
builder.Services.AddSingleton<IClock, SystemClock>();
builder.Services.AddScoped<IUnitOfWork, EfUnitOfWork>();
builder.Services.AddTransient<EmailComposer>();
builder.Services.AddOptions<SmtpOptions>()
.BindConfiguration("Smtp")
.ValidateDataAnnotations()
.ValidateOnStart();
public sealed class MailService(IClock clock, IOptions<SmtpOptions> options)
{
public string Host => options.Value.Host;
}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)
{
ArgumentNullException.ThrowIfNull(onEach);
foreach (var item in items) onEach(item);
}
// 완료와 취소를 호출자가 관찰해야 하는 비동기 콜백
Func<CancellationToken, Task> refreshAsync = ct => Task.Delay(100, ct);
await refreshAsync(CancellationToken.None);내장 어트리뷰트([Obsolete], [Flags], [CallerMemberName])의 동작 원리, 커스텀 어트리뷰트 선언과 리플렉션으로 읽는 패턴, AttributeTargets 제한 방법을 정리합니다.
using System.Reflection;
// 내장 어트리뷰트
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public sealed class AuditAttribute : Attribute
{
public string Reason { get; }
public AuditAttribute(string reason) => Reason = reason;
}
public sealed class PaymentService
{
[Obsolete("V2 API를 사용하세요", error: false)]
public void OldMethod() { }
[Audit("결제 처리 - 감사 로그 필수")]
public void ProcessPayment() { }
}
// 리플렉션으로 읽기
var attr = typeof(PaymentService)
.GetMethod("ProcessPayment")
?.GetCustomAttribute<AuditAttribute>();
Console.WriteLine(attr?.Reason);