DEVSIGHT

C#, Sliding Window(Two Pointers) 구현

Sat, 02 May 2026 00:00:00 +0900

슬라이딩 윈도우(Sliding Window)는 고정된 크기의 창(Window)을 옆으로 밀면서 데이터를 처리하는 알고리즘 기법입니다. 중복 계산을 줄여 시간 복잡도를 (O(n))으로 최적화하는 데 매우 유용하다.¹

또한, 매번 처리되는 중복된 요소를 버리지 않고 재사용함으로써 낭비되는 계산을 하지 않음으로써 효율적으로 처리하는 방법이다.²

문자열 처리에서 Dictionary<char, int>나 int[] 배열을 활용해 투 포인터(Two Pointers) 방식으로 직접 구현하면 IndexOf보다 훨씬 효율적인 $O(N)$ 성능의 함수를 만들 수 있다.

Substring 사용은 메모리 할당(GC 과부하)이 발생하여 윈도우가 움직일 때마다 Substring을 호출하면 성능이 급격히 떨어진다. 이때 Span<T> 또는 ReadOnlySpan<char>를 사용하면 메모리 복사 없이 문자열의 특정 구간을 가리킬 수 있다.

ReadOnlySpan<char> window = s.AsSpan().Slice(left, right - left + 1);

사용 예제

// 최소 구간 찾기 (Minimum Window Substring)
// 출력: BANC
const string text1 = "ADOBECODEBANC";
ReadOnlySpan<char> minWin = SlidingWindow.GetMinWindow(text1, "ABC");
LogHelper.Debug($"최소 구간 찾기 : {minWin.ToString()}");

// 중복 없는 가장 긴 문자열 길이
// 출력: 3 (abc)
const string text2 = "abcabcbb";
int longLen = SlidingWindow.GetLongestUniqueLength(text2);
LogHelper.Debug($"중복 없는 최장 길이: {longLen}"); 

// 애너그램 위치 찾기
// 출력: 0, 6
const string text3 = "cbaebabacd";
List<int> anagrams = SlidingWindow.FindAnagrams(text3, "abc");
LogHelper.Debug($"애너그램 인덱스: {string.Join(", ", anagrams)}");

// K개 고유 문자 포함 최장 길이
// 출력: 3 (ece)
const string text4 = "eceba";
int kLen = SlidingWindow.GetMaxKUniqueLength(text4, 2);
LogHelper.Debug($"최대 2개 고유문자 최장 길이: {kLen}"); 

Sliding Window 함수

함수명	핵심 목표	윈도우 크기	핵심 데이터 구조
GetMinWindow	조건 만족하는 최소 길이	가변 (수축 중심)	`int[]` (필요 빈도수)
GetLongestUnique	중복 없는 최대 길이	가변 (확장 중심)	`int[]` (마지막 위치)
FindAnagrams	구성이 일치하는 모든 위치	고정	`int[]` (고정 빈도수)
GetMaxKUnique	종류가 K개 이하인 최대 길이	가변 (확장 중심)	`int[]` (현재 종류수)

최대 K개의 고유 문자(Unique Characters)를 포함하는 가장 긴 부분 문자열 찾기

예시 (K = 2 일 때) : 문자열 : a a b a c b e

[a a] : 고유 문자 1종 (a) - 통과
[a a b] : 고유 문자 2종 (a, b) - 통과
[a a b a] : 고유 문자 2종 (a, b) - 통과 (현재 최장 길이: 4)
[a a b a c] : 고유 문자 3종 (a, b, c) - 실패! (K=2를 초과함)
이제 왼쪽에서 하나씩 뺀다.
[a b a c] (3종), [b a c] (3종), [a c] (2종) … 다시 조건을 만족할 때까지 줄인다

결과적으로 위 문자열에서 K=2일 때 가장 긴 구간은 aaba로 길이는 4가 된다.

모든 문자를 포함하는 최소 구간 찾기 (Minimum Window Substring)

데이터 필터링 및 요약
로그 분석: 세 키워드 모두 등작하는 가장 짧은 타임라인 추출
문서 요약: 검색한 키워드들이 모두 포함된 가장 짧은 문장 찾기)
Left 최대 수축

public static ReadOnlySpan<char> GetMinWindow(string s, string t)
{
    if (string.IsNullOrWhiteSpace(s) || string.IsNullOrWhiteSpace(t))
    {
        return ReadOnlySpan<char>.Empty;
    }

    try
    {
        int[] targetMap = new int[128];

        foreach (char c in t)
        {
            targetMap[c]++;
        }

        int[] windowMap = new int[128];
        int left = 0, count = 0, minLen = int.MaxValue, startIndex = 0;
        int required = t.Distinct().Count();

        for (int right = 0; right < s.Length; right++)
        {
            char rChar = s[right];
            windowMap[rChar]++;

            if (targetMap[rChar] > 0 && windowMap[rChar] == targetMap[rChar])
            {
                count++;
            }

            while (count == required)
            {
                if (right - left + 1 < minLen)
                {
                    minLen = right - left + 1;
                    startIndex = left;
                }

                char lChar = s[left];

                if (targetMap[lChar] > 0 && windowMap[lChar] == targetMap[lChar])
                {
                    count--;
                }

                windowMap[lChar]--;
                left++;
            }
        }

        return minLen == int.MaxValue
            ? ReadOnlySpan<char>.Empty
            : s.AsSpan().Slice(startIndex, minLen);
    }
    catch (Exception ex)
    {
        LogHelper.Error($"GetMinWindow Error : {ex.Message}");
        return ReadOnlySpan<char>.Empty;
    }
}

중복 문자가 없는 가장 긴 부분 문자열 (Longest Substring Without Repeating)

고유성 검사 및 패턴 인식
보안 인증: 일회용 비밀번호(OTP)나 난수 생성기에서 문자가 겹치지 않고 연속해서 나올 수 있는 최대 성능 측정
데이터 압축: 반복되지 않는 문자열 구간을 찾아 효율적인 압축 사전을 만들 때
중복 발생 시 포인터 점프

public static int GetLongestUniqueLength(string s)
{
    if (string.IsNullOrWhiteSpace(s))
    {
        return 0;
    }

    try
    {
        int[] lastSeen = new int[128];
        Array.Fill(lastSeen, -1);
        int maxLength = 0, left = 0;

        for (int right = 0; right < s.Length; right++)
        {
            if (lastSeen[s[right]] >= left)
            {
                left = lastSeen[s[right]] + 1;
            }

            lastSeen[s[right]] = right;
            maxLength = Math.Max(maxLength, right - left + 1);
        }

        return maxLength;
    }
    catch (Exception ex)
    {
        LogHelper.Error($"GetLongestUniqueLength Error : {ex.Message}");
        return 0;
    }
}

애너그램 시작 위치 모두 찾기 (Find All Anagrams)

패턴 매칭 및 암호 해석
유전자 분석: DNA 염기 서열(ATGC)에서 순서는 다르지만 구성 성분이 같은 특정 유전자 마커를 찾을 때
철자 검사기: 사용자가 입력한 단어의 철자를 조합해서 만들 수 있는 단어가 본문에 어디어디 숨어있는지 찾을 때
대상(p.Length)으로 고정

public static List<int> FindAnagrams(string s, string p)
{
    List<int> indices = [];

    if (s.Length < p.Length)
    {
        return indices;
    }

    try
    {
        int[] pCount = new int[128];
        int[] sCount = new int[128];

        foreach (char c in p)
        {
            pCount[c]++;
        }

        for (int i = 0; i < s.Length; i++)
        {
            sCount[s[i]]++;

            if (i >= p.Length)
            {
                sCount[s[i - p.Length]]--;
            }

            if (i < p.Length - 1)
            {
                continue;
            }

            if (AreCountsEqual(pCount, sCount))
            {
                indices.Add(i - p.Length + 1);
            }
        }

        return indices;
    }
    catch (Exception ex)
    {
        LogHelper.Error($"FindAnagrams Error : {ex.Message}");
        return indices;
    }

    // Span을 이용한 빈도 배열 비교
    bool AreCountsEqual(int[] a, int[] b)
    {
        return a.AsSpan().SequenceEqual(b.AsSpan());
    }
}

최대 K개의 고유 문자를 포함하는 가장 긴 구간

자원 제한 조건에서의 최대 효율 탐색
스트리밍 최적화: “서로 다른 화질(Resolution) 종류를 최대 2개까지만 유지하면서 끊김 없이 보낼 수 있는 가장 긴 시간대” 계산.
마케팅: 고객의 구매 이력에서 “최대 3종류의 카테고리 물건만 사면서 가장 길게 이어진 쇼핑 세션”을 분석하여 고객 성향 파악.
윈도우 내부의 ‘종류(Count)’

public static int GetMaxKUniqueLength(string s, int k)
{
    if (string.IsNullOrWhiteSpace(s) || k == 0)
    {
        return 0;
    }

    int[] counts = new int[128];
    int left = 0, distinctCount = 0, maxLen = 0;

    for (int right = 0; right < s.Length; right++)
    {
        if (counts[s[right]] == 0)
        {
            distinctCount++;
        }

        counts[s[right]]++;

        while (distinctCount > k)
        {
            counts[s[left]]--;
            if (counts[s[left]] == 0) distinctCount--;
            left++;
        }

        maxLen = Math.Max(maxLen, right - left + 1);
    }

    return maxLen;
}

Rust, `windows()` 예제

Rust는 C#과 달리 표준 라이브러리의 slice 유니티에 windows()라는 메서드가 내장되어 있다. C#과 의 가장 큰 차이점은 Rust의 windows()는 데이터를 복사하지 않고 참조(Reference)만 넘겨준다는 점이다.

fn main() {
    let words = vec!["A", "B", "C", "D", "E"];

    // 크기가 3인 창(Window)을 만들어서 한 칸씩 이동
    for window in words.windows(3) {
        // window는 순서로 참조, ["A", "B", "C"], ["B", "C", "D"]
        println!("{:?}", window);
    }
}

인접한 요소 비교하기

fn main() {
    let prices = vec![100, 150, 120, 200, 180];

    // 크기가 2인 윈도우를 사용해 가격 변동 분석
    for w in prices.windows(2) {
        let diff = w[1] - w[0];
        let status = if diff > 0 { "상승" } else { "하락" };
        println!("{} -> {}: {} ({})", w[0], w[1], diff.abs(), status);
    }
}

애너그램 : C#과 비교해서 코드가 간결 함.

fn find_anagrams(s: &str, p: &str) -> Vec<usize> {
    let mut result = Vec::new();
    let p_len = p.len();
    let s_bytes = s.as_bytes();
    
    // 정렬된 target (비교용)
    let mut p_sorted = p.as_bytes().to_vec();
    p_sorted.sort();

    // windows(p_len)을 사용해 슬라이딩 윈도우 자동 생성
    for (i, window) in s_bytes.windows(p_len).enumerate() {
        let mut temp = window.to_vec();
        temp.sort();
        if temp == p_sorted {
            result.add(i);
        }
    }
    result
}

Rust의 내장 windows(n)는 윈도우 크기가 n으로 고정된 경우에만 사용할 수 있다. &str에서 바로 사용할 수 없고 바이트 단위나 유니코드 스칼라(chars()) 단위로 변환 후 사용해야 한다.

슬라이딩 윈도우 vs 투 포인터³

구분	슬라이딩 윈도우	투 포인터
윈도우 크기	고정됨 (K)	가변적임 (조건에 따라 변화)
주요 목적	연속된 구간의 합/평균 최적화	구간 내 특정 조건을 만족하는 쌍 찾기

Reference

“윈도잉(windowing) 기법을 적용한 고성능 표 컴포넌트 개발기”, <NAVER D2>, 2025.07.24, https://d2.naver.com/helloworld/1450243, 2026.05.02.

“슬라이딩윈도우 알고리즘(feat.Javascript)”, <endmoseung>, 2022.10.12, https://velog.io/@endmoseung/슬라이딩윈도우-알고리즘feat.Javascript, 2016.05.02.

“단순화된 슬라이딩 윈도우 기법”, <Linkedin>, 2024.10.24, https://kr.linkedin.com/pulse/sliding-window-technique-simplified-c-rishabh-singh-1b3te, 2026.05.02.

C#, Result Pattern 구현

Tue, 21 Apr 2026 00:00:00 +0900

C# Result Pattern은 메서드가 성공 또는 실패(오류) 상태와 관련 데이터를 포함한 객체를 반환하도록 하여, 예외(Exception) 대신 명시적으로 결과를 처리하는 디자인 패턴이다.¹

작업의 성공 또는 실패를 명시적으로 반환하여 예외(Exception) 대신 구조화된 객체를 통해 에러를 처리하는 디자인 패턴이다. 주로 함수형 프로그래밍 접근 방식을 활용하여 코드의 가독성, 유지보수성, 예측 가능성을 높이며, ‘성공 시 데이터’와 ‘실패 시 에러 정보’를 하나의 객체로 캡슐화한다.²

이걸 구현하는 비슷한 패키지로는 OneOf가 있지만 오래되었고 좀 더 Customizing 할 수 있게 직접 구현해 보았다. 아래에 전체 소스를 추가하였다.

활용 예제

public Result<string> GetUsername(int id)  
{  
    return id switch  
    {  
        < 0 => Result<string>.Failure("잘못된 접근입니다.", 400),  
        0 => None.Value,  
        _ => "DebugJO"  
    };  
}

Result<string> result = GetUsername(-1);  
  
string message = result.Match(  
    success: name => $"사용자: {name}",  
    none: () => "사용자를 찾을 수 없습니다.",  
    failure: (msg, code) => $" 오류({code}): {msg}"  
);  
Console.WriteLine($"message = {message}");  

서비스 등록 예제

public interface IUserService {  
    Result<string> GetUserName(int id);  
}  
  
public class UserService : IUserService  
{  
    public Result<string> GetUserName(int id)  
    {  
        if (id == 0) return None.Value;  
        return "DebugJO";  
    }  
}

builder.Services.AddScoped<IUserService, UserService>();

public class UserController(IUserService userService) : ControllerBase  
{  
    public IActionResult Get(int id)  
    {  
        // 서비스에서 Result<string>을 받아와서 Match로 처리  
        return userService.GetUserName(id).Match<IActionResult>(  
            success: name => Ok(name),  
            none: () => NotFound(),  
            failure: (msg, code) => StatusCode(code, msg)  
        );  
    }  
}

public IActionResult Process(int id)  
{  
    var userResult = _userService.GetUserName(id);  
      
    // 패턴 매칭을 통해 아주 선언적으로 작성 가능  
    return userResult.Match<IActionResult>(  
        success: name => Ok($"어서오세요, {name}님"),  
        none: () => NotFound("사용자를 찾을 수 없습니다."),  
        failure: (msg, code) => StatusCode(code, msg)  
    );  
}

추가 예제, 리턴 타입

public Result<string> ProcessPayment(decimal amount)  
{  
    switch (amount)  
    {  
        // if (!User.IsAuthenticated)   
case > 30:  
            return ResultExtensions.ToUnauthorized<Result<string>, string>();  
        case <= 0:  
            return ResultExtensions.ToBadRequest<Result<string>, string>("금액이 올바르지 않습니다.");  
        default:  
        {  
            string receipt = $"결제 완료: {amount}원";  
            return receipt.ToSuccess<Result<string>, string>();  
        }  
    }  
}

Result<string> result = ProcessPayment(1000);  
result.Match(  
    success: s => Console.WriteLine($"결과 : {s}")
    none: () => Console.WriteLine("결과 없음"),  
    failure: (msg, code) => Console.WriteLine($"Error {code}: {msg}")  
);

코드 추가

public static class ErrorCodes  
{  
    public const int InvalidInput = 400;  
    public const int Unauthorized = 401;  
    public const int NotFound = 404;  
    public const int ServerError = 500;  
}

public Result<User> GetUserAccount(int id)  
{  
    if (id < 0)   
        return Result<User>.Failure("아이디는 음수일 수 없습니다.", ErrorCodes.InvalidInput);  
  
    if (id == 999) // 특정 금지된 아이디 가정  
        return Result<User>.Failure("접근 권한이 없는 계정입니다.", ErrorCodes.Unauthorized);  
  
    var user = _repository.Find(id);  
    if (user == null) return None.Value;  
  
    return user; // 성공 (자동 형변환)  
}

전체 소스

public interface IResult<out TSelf, in TValue> where TSelf : IResult<TSelf, TValue>  
{  
    static abstract TSelf Success(TValue value);  
  
    static abstract TSelf Failure(string message, int errorCode = 500);  
}  
  
public record Result<T> : IResult<Result<T>, T>  
{  
    public T? Value { get; }  
    public string? ErrorMessage { get; }  
    public int ErrorCode { get; }  
    public ResultState State { get; }  
  
    public enum ResultState  
    {  
        Success,  
        None,  
        Failure  
    }  
  
    private Result(ResultState state, T? value, string? error, int code)  
    {  
        State = state;  
        Value = value;  
        ErrorMessage = error;  
        ErrorCode = code;  
    }  
  
    public static Result<T> Success(T value) => new(ResultState.Success, value, null, 0);  
  
    public static Result<T> Failure(string message, int errorCode = 500)  
        => new(ResultState.Failure, default, message, errorCode);  
  
    public static Result<T> None() => new(ResultState.None, default, null, 0);  
  
    public static implicit operator Result<T>(T value) => Success(value);  
  
    public static implicit operator Result<T>(None _) => None();  
  
    public TResult Match<TResult>(Func<T, TResult> success, Func<TResult> none, Func<string, int, TResult> failure)  
        => State switch  
        {  
            ResultState.Success => success(Value!),  
            ResultState.None => none(),  
            ResultState.Failure => failure(ErrorMessage!, ErrorCode),  
            _ => throw new InvalidOperationException()  
        };  
  
    public void Match(Action<T> success, Action none, Action<string, int> failure)  
    {  
        switch (State)  
        {  
            case ResultState.Success: success(Value!); break;  
            case ResultState.None: none(); break;  
            case ResultState.Failure: failure(ErrorMessage!, ErrorCode); break;  
            default: throw new InvalidOperationException();  
        }  
    }  
}  
  
public readonly struct None  
{  
    public static None Value => new();  
}  
  
public static class ResultExtensions  
{  
    // 공통 실패 처리 (400 Bad Request)    
    public static TResult ToBadRequest<TResult, TValue>(string message)  
        where TResult : IResult<TResult, TValue>  
        => TResult.Failure(message, 400);  
  
    // 공통 실패 처리 (401 Unauthorized)    
    public static TResult ToUnauthorized<TResult, TValue>(string message = "인증되지 않았습니다.")  
        where TResult : IResult<TResult, TValue>  
        => TResult.Failure(message, 401);  
  
    // 공통 성공 처리 (단순 값을 결과 객체로 변환)  
    public static TResult ToSuccess<TResult, TValue>(this TValue value)  
        where TResult : IResult<TResult, TValue>  
        => TResult.Success(value);  
}

서비스 등록	인스턴스 생성 시점 및 공유 범위
`AddSingleton`	애플리케이션 시작 후 최초 요청 시 딱 한 번 생성하며, 모든 사용자가 동일한 인스턴스를 공유
`AddScoped`	HTTP 요청(Request) 하나당 하나 생성. 같은 요청 내에서는 동일한 인스턴스를 공유하지만, 다른 요청과는 공유하지 않음
`AddTransient`	서비스가 주입될 때마다 항상 새로운 인스턴스를 생성. 가장 수명이 짧다

Reference

“C# The Result Pattern in C#: A comprehensive guide”, <Linkedin>, 2024.11.27, https://www.linkedin.com/pulse/result-pattern-c-comprehensive-guide-andre-baltieri-wieuf, 2026.04.21.

“C# Result Pattern in .NET and C#”, <Github>, 2024.07.01, https://github.com/karanraj-tech/result-pattern, 2026.04.21.

C#, 고성능 Tag Search

Sat, 11 Apr 2026 00:00:00 +0900

태그(tag) 조회 성능을 위해 Aho-Corasick 알고리즘을 사용하는데 이를 위해 .NET 9 이상에서 제공하는 SearchValues<string> 함수를 이용하는 예제이다.

최적화 핵심은 그룹화, 길이 내림차순 정렬, FrozenDictionary (읽기 전용 최적화 컬렉션) 자료구조이다. IndexOfAny로 특정 단어로 시작하는 단어들만 루프를 돌게 한다. Greedy Matching (긴 단어 우선), ReadOnlySpan<char>으로 메모리(GC) 최적화 등을 포함한다.

성능을 위해 Parallel.ForEach로 문서를 문단 단위로 나누어 병렬처리할 수 있다.

유의어(Alias) 사전 운영은 {"ID": 1, "Name": "LG", "Aliases": ["LG전자", "LG디스플레이", "LGCNS", "LG CNS"]} 이런 식으로 관리하고, SearchValues 엔진에는 Aliases에 있는 모든 단어를 다 때려 넣고 무엇이 걸리든 결과는 "ID": 1(LG)로 리턴하게 만드는 방식을 사용한다.

Program.cs

using System;  
using System.Collections.Generic;  
using System.Threading.Tasks;  
  
namespace ConsoleApp;  
  
internal class Program  
{  
    private static async Task Main()  
    {  
        // tag dictionary는 DB에서 불러온다고 가정  
        string[] myDictionary =  
            ["삼성전자", "현대차", "LG", "SK하이닉스", "C#", ".NET", "삼성"];  
  
        const string document = "삼성전자는 이번 분기 실적 발표에서 현대차와의 협업을 발표했습니다. 또한 C#과 NET 환경에서의 소프트웨어 최적화가 중요해지고 있으며, SK하이닉스의 반도체 기술도 언급되었습니다."; 
  
        // ~ 10,000 태그 가정  
        TagProcessor tagProcessor = new(myDictionary);  
        List<string> tags = tagProcessor.ExtractAllTags(document);  
        Console.WriteLine($"추출된 태그 개수 : {tags.Count}");  
  
        foreach (string tag in tags)  
        {  
            Console.WriteLine($"- {tag}");  
        }  
  
        Console.WriteLine("----------------------------");  
  
        // 10,000 ~ 100,000개 태그 가정  
        Console.WriteLine("태그 추출 시작 ...");  
          
        List<string> extractTags = await Task.Run(() =>  
        {  
            HighDensityTagProcessor hightProcessor = new(myDictionary);  
            return hightProcessor.ExtractTags(document);  
        });  
          
        Console.WriteLine($"추출된 태그 개수(High) : {extractTags.Count}");  
  
        foreach (string tag in extractTags)  
        {  
            Console.WriteLine($"- {tag}");  
        }  
          
        Console.WriteLine("태그 추출 완료");  
    }  
}

TagProcessor.cs

using System;  
using System.Buffers;  
using System.Collections.Frozen;  
using System.Collections.Generic;  
using System.Linq;  
  
namespace ConsoleApp;  
  
public class TagProcessor  
{  
    // 빠른 위치 점프  
    private readonly SearchValues<string> mTagEngine;  
  
    // 첫 글자로 그룹화하여 검사 대상 최소화  
    private readonly FrozenDictionary<char, string[]> mTagLookup;  
  
    public TagProcessor(IEnumerable<string>? tags)  
    {  
        string[] myDictionary = tags?.Distinct().ToArray() ?? [];  
  
        if (myDictionary.Length == 0)  
        {  
            throw new ArgumentException("태그 리스트가 비어 있어 프로세서를 생성할 수 없습니다.", nameof(tags));  
        }  
  
        mTagEngine = SearchValues.Create(myDictionary, StringComparison.OrdinalIgnoreCase);  
  
        mTagLookup = myDictionary  
            .GroupBy(t => char.ToLowerInvariant(t[0]))  
            .ToDictionary(  
                g => g.Key,  
                g => g.OrderByDescending(t => t.Length).ToArray()  
            )  
            .ToFrozenDictionary();  
    }  
  
    public List<string> ExtractAllTags(string document)  
    {  
        if (string.IsNullOrEmpty(document))  
        {  
            return [];  
        }  
  
        HashSet<string> foundTags = new(StringComparer.OrdinalIgnoreCase);  
        ReadOnlySpan<char> span = document.AsSpan();  
  
        while (true)  
        {  
            // 하드웨어 가속 점프  
            int index = span.IndexOfAny(mTagEngine);  
  
            if (index < 0)  
            {  
                break;  
            }  
  
            span = span[index..];  
            char firstChar = char.ToLowerInvariant(span[0]);  
  
            if (mTagLookup.TryGetValue(firstChar, out string[]? candidates))  
            {  
                bool matched = false;  
                // 현재 남은 문장 길이  
                int spanLength = span.Length;  
  
                foreach (string tag in candidates)  
                {  
                    // 남은 문장보다 태그가 길면 절대 매칭 검사 생략  
                    if (tag.Length > spanLength)  
                    {  
                        continue;  
                    }  
  
                    if (!span.StartsWith(tag, StringComparison.OrdinalIgnoreCase))  
                    {  
                        continue;  
                    }  
  
                    foundTags.Add(tag);  
                    span = span[tag.Length..];  
                    matched = true;  
                    break;  
                }  
  
                if (matched)  
                {  
                    if (span.IsEmpty)  
                    {  
                        break;  
                    }  
  
                    continue;  
                }  
            }  
  
            // 매칭 실패 시 1글자 전진  
            span = span[1..];  
  
            if (span.IsEmpty)  
            {  
                break;  
            }  
        }  
  
        return foundTags.ToList();  
    }  
}

HighDensityTagProcessor.cs

using System;  
using System.Buffers;  
using System.Collections.Frozen;  
using System.Collections.Generic;  
using System.Linq;  
  
namespace ConsoleApp;  
  
public class HighDensityTagProcessor  
{  
    private readonly SearchValues<string> mTagEngine;  
    private readonly FrozenDictionary<string, string[]> mTagLookup;  
    private readonly int mMinTagLength;  
    private readonly bool mUseDoublePrefix; // 2글자 인덱스 플래그  
  
    public HighDensityTagProcessor(IEnumerable<string>? tags, bool useDoublePrefix = true)  
    {  
        string[] tagList = tags?.Distinct().ToArray() ?? [];  
  
        if (tagList.Length == 0)  
        {  
            throw new ArgumentException("태그 리스트가 비어 있어 프로세서를 생성할 수 없습니다.", nameof(tags));  
        }  
  
        mUseDoublePrefix = useDoublePrefix;  
        mMinTagLength = tagList.Min(t => t.Length);  
        mTagEngine = SearchValues.Create(tagList, StringComparison.OrdinalIgnoreCase);  
  
        mTagLookup = tagList  
            .GroupBy(t => GetKey(t, mUseDoublePrefix))  
            .ToDictionary(  
                g => g.Key,  
                g => g.OrderByDescending(t => t.Length).ToArray()  
            )  
            .ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);  
    }  
  
    private static string GetKey(string tag, bool useDouble)  
    {  
        int len = (useDouble && tag.Length >= 2) ? 2 : 1;  
        return tag[..len].ToLowerInvariant();  
    }  
  
    public List<string> ExtractTags(string document)  
    {  
        if (string.IsNullOrEmpty(document) || document.Length < mMinTagLength)  
        {  
            return [];  
        }  
  
        HashSet<string> foundTags = new(StringComparer.OrdinalIgnoreCase);  
        ReadOnlySpan<char> span = document.AsSpan();  
  
        while (span.Length >= mMinTagLength)  
        {  
            int index = span.IndexOfAny(mTagEngine);  
  
            if (index < 0)  
            {  
                break;  
            }  
  
            span = span[index..];  
  
            if (span.Length < mMinTagLength)  
            {  
                break;  
            }  
  
            bool matched = false;  
  
            if (mUseDoublePrefix && span.Length >= 2)  
            {  
                if (TryMatch(span[..2].ToString(), span, foundTags, out int matchedLength))  
                {  
                    span = span[matchedLength..];  
                    matched = true;  
                }  
            }  
  
            if (!matched)  
            {  
                if (TryMatch(span[..1].ToString(), span, foundTags, out int matchedLength))  
                {  
                    span = span[matchedLength..];  
                    matched = true;  
                }  
            }  
  
            if (!matched)  
            {  
                span = span[1..];  
            }  
        }  
  
        return foundTags.ToList();  
    }  
  
    private bool TryMatch(string key, ReadOnlySpan<char> span, HashSet<string> foundTags, out int matchedLength)  
    {  
        matchedLength = 0;  
  
        if (!mTagLookup.TryGetValue(key, out string[]? candidates))  
        {  
            return false;  
        }  
  
        foreach (string tag in candidates)  
        {  
            if (span.Length < tag.Length || !span.StartsWith(tag, StringComparison.OrdinalIgnoreCase))  
            {  
                continue;  
            }  
  
            foundTags.Add(tag);  
            matchedLength = tag.Length;  
            return true;  
        }  
  
        return false;  
    }  
}

throw 대표적인 예외

1.매개변수(인자) 값이 잘못되었을 때

ArgumentNullException: 전달된 인자가 null이면 안 될 때
ArgumentOutOfRangeException: 숫자가 범위를 벗어났을 때
ArgumentException: 그 외에 값이 잘못되었을 때 (포괄)

2.객체의 상태가 올바르지 않을 때

InvalidOperationException: 메서드를 호출하기 위한 전제 조건이 맞지 않을 때
ObjectDisposedException: 리소스가 해제(Dispose)된 객체를 다시 사용하려고 할 때

3.아직 구현하지 않았거나 지원하지 않을 때

NotImplementedException: 메서드 틀만 있고 코드는 없을 때(메모용)
NotSupportedException: 해당 기능이 지원되지 않을 때

Debug.Assert vs if (throw) 차이

구분	Debug.Assert	if (tagList.Length == 0) throw
작동 환경	Debug 모드에서만 작동	Debug/Release 모두 작동
실행 결과	개발 중 팝업창이 뜨거나 로그가 찍힘	프로그램이 예외를 발생시키며 중단됨
용도	개발자의 실수를 잡을 때 (버그 방지)	사용자의 입력값이나 데이터가 잘못되었을 때

C#에서 C++, Rust, Zig 라이브러리 사용하기

Sat, 11 Apr 2026 00:00:00 +0900

이전 글 C# AOT 라이브러리 활용에서 C++ constexpr, zig comptime, rust의 매크로 함수인 obfstr! 함수를 이용하여 컴파일 타임에 문자열을 난독화하는 예제를 소개했는데 이번 글에서 Native 컴파일 언어로 각각 구현하였다.

CppNative.dll , rust_native.dll , zig_native.dll (Zig는 0.16dev 버전)

graph LR
A["Native Library<br/>(Cpp, Rust, Zig)"]
-->B["Unmanaged C#(AOT)<br/>(ConsoleAppNative.dll)"]
B-->C["Manged C#<br/>(ConsoleApp.exe)"]

개발 환경

Cpp : Clion + 툴체인(Visusql Studio 2022)
Rust : RustRover + rust 1.94.1
Zig : VSCode + zig 0.16.0-dev.3133+5ec8e45f3
C# : Rider + .net 10

전체 예제는 Github에서 볼 수 있다.

Cpp : CMakeList.txt

cmake_minimum_required(VERSION 4.2)  
project(CppNative)  
set(CMAKE_CXX_STANDARD 20)  
  
add_compile_options(/utf-8)  
# 정적 컴파일  
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")  
# 동적 컴파일 : dumpbin /dependents CppNative.dll 확인  
# set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")  
add_library(CppNative SHARED  
        library.cpp  
)  
set_target_properties(CppNative PROPERTIES OUTPUT_NAME "CppNative" PREFIX "")  
  
# 동적 컴파일 시 사용  
#if (CMAKE_BUILD_TYPE STREQUAL "Debug")  
#    set(CMAKE_INSTALL_DEBUG_LIBRARIES ON)  
#endif ()  
#include(InstallRequiredSystemLibraries)  
set(DEPLOY_DIR "${CMAKE_SOURCE_DIR}/deploy/$<CONFIG>")  
add_custom_command(TARGET CppNative POST_BUILD  
        COMMAND ${CMAKE_COMMAND} -E make_directory "${DEPLOY_DIR}"  
        COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:CppNative> "${DEPLOY_DIR}"  
        # 동적 컴파일 시 사용  
        #COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} "${DEPLOY_DIR}"  
        COMMENT "Deploying CppNative.dll and system dependencies to ${DEPLOY_DIR}"  
)

Cpp : library.h

#pragma once  
#include <string>  
#include <array>  
  
template<size_t N>  
class ObfuscatedString {  
public:  
    template<size_t... Is>  
    constexpr ObfuscatedString(const char *str, char key, std::index_sequence<Is...>)  
        : m_key(key), m_data{static_cast<char>(str[Is] ^ key)...} {  
    }  
  
    [[nodiscard]] std::string decrypt() const {  
        std::string result;  
        result.reserve(N);  
        for (size_t i = 0; i < N; ++i) {  
            result += static_cast<char>(m_data[i] ^ m_key);  
        }  
        return result;  
    }  
  
private:  
    char m_key;  
    std::array<char, N> m_data;  
};  
  
#define OBFUSCATE(str) ([]() { \  
    constexpr size_t _len = sizeof(str); \  
    return ObfuscatedString<_len>(str, 0x5A, std::make_index_sequence<_len>{}); \  
}())  
  
#if defined(_WIN32)  
#define MY_API __declspec(dllexport)  
#else  
#define MY_API __attribute__((visibility("default")))  
#endif  
  
extern "C" {  
MY_API int GetSecretData(char *buffer, int obfuscatedKey);  
}

Cpp : library.cpp

#include "library.h"  
#include <iostream>  
  
#define FIXED_BUFFER_SIZE 1024  
#define SALT 0x1234  
#define VALID_KEY 0x7777  
  
int GetSecretData(char *buffer, const int obfuscatedKey) {  
    if ((obfuscatedKey ^ SALT) != VALID_KEY) {  
        return -1;  
    }  
  
    static ObfuscatedString<sizeof ("cpp 보안 문자열")> secret = OBFUSCATE("cpp 보안 문자열");  
    const std::string decrypted = secret.decrypt();  
  
    if (buffer != nullptr) {  
        const size_t len = (decrypted.length() < FIXED_BUFFER_SIZE) ? decrypted.length() : FIXED_BUFFER_SIZE - 1;  
        memcpy(buffer, decrypted.c_str(), len);  
        buffer[len] = '\0';  
        return static_cast<int>(len);  
    }  
    return 0;  
}

Rust : Cargo.toml

[package]  
name = "rust_native"  
version = "0.1.0"  
edition = "2024"  
  
[lib]  
crate-type = ["cdylib"]  
  
[dependencies]  
obfstr = "0.4.4"  
  
[profile.release]  
opt-level = "z"   # 크기 최적화 (s 또는 z)
lto = true        # 전체 프로그램 최적화  
codegen-units = 1 # 최적화 품질 향상  
panic = "abort"   # 예외 발생 시 즉시 종료 (FFI 안전성)

Rust : config.toml

[target.x86_64-pc-windows-msvc]  
rustflags = ["-C", "target-feature=+crt-static"]  
  
[target.i686-pc-windows-msvc]  
rustflags = ["-C", "target-feature=+crt-static"]

Rust : lib.rs

use obfstr::obfbytes;  
use std::ptr;  
  
const SALT: i32 = 0x1234;  
const VALID_KEY: i32 = 0x7777;  
const MAX_INTERNAL_BUFFER: usize = 1024;  
  
#[unsafe(no_mangle)]  
pub extern "C" fn get_secret_data(buffer: *mut u8, buffer_len: i32, obfuscated_key: i32) -> i32 {  
    if buffer.is_null() || buffer_len <= 0 {  
        return 0;  
    }  
  
    if (obfuscated_key ^ SALT) != VALID_KEY {  
        return -1;  
    }  
  
    let bytes: &[u8; 21] = obfbytes!("rust 보안 문자열".as_bytes());  
    let safe_limit: usize = (buffer_len as usize).min(MAX_INTERNAL_BUFFER);  
    let copy_len: usize = bytes.len().min(safe_limit - 1);  
  
    unsafe {  
        ptr::copy_nonoverlapping(bytes.as_ptr(), buffer, copy_len);  
        ptr::write(buffer.add(copy_len), 0);  
    }  
  
    copy_len as i32  
}  
  
#[cfg(test)]  
mod tests {  
    #[test]  
    fn check_string_len() {  
        let s: &str = "rust 보안 문자열";  
        println!("바이트 길이: {}", s.len());  
        //assert_eq!(s.len(), 21);  
    }  
}  
  
// cargo test -- --nocapture  
// cargo build --release

Zig : build.zig

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const lib = b.addLibrary(.{
        .name = "zig_native",
        .linkage = .dynamic,
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    b.installArtifact(lib);
}

// zig build -Doptimize=ReleaseSmall

Zig : main.zig

const std = @import("std");

const SALT: i32 = 0x1234;
const VALID_KEY: i32 = 0x7777;
const XOR_KEY: u8 = 0x5A;
const MAX_INTERNAL_BUFFER: usize = 1024;

fn obfuscate(comptime str: []const u8) [str.len]u8 {
    var res: [str.len]u8 = undefined;
    for (str, 0..) |c, i| {
        res[i] = c ^ XOR_KEY;
    }
    return res;
}

const secret_data = obfuscate("zig 보안 문자열");

export fn get_secret_data(buffer: [*]u8, buffer_len: i32, obfuscated_key: i32) callconv(.c) i32 {
    if (buffer_len <= 0) {
        return 0;
    }

    if ((obfuscated_key ^ SALT) != VALID_KEY) {
        return -1;
    }

    const safe_limit = @as(usize, @intCast(buffer_len));

    const internal_limit =
        if (safe_limit < MAX_INTERNAL_BUFFER)
            safe_limit
        else
            MAX_INTERNAL_BUFFER;

    const copy_len =
        if (secret_data.len < internal_limit)
            secret_data.len
        else
            internal_limit - 1;

    var i: usize = 0;

    while (i < copy_len) : (i += 1) {
        buffer[i] = secret_data[i] ^ XOR_KEY;
    }

    buffer[copy_len] = 0;
    return @as(i32, @intCast(copy_len));
}

C# : ConsoleApp.csproj

<Project Sdk="Microsoft.NET.Sdk">  
    <PropertyGroup>  
        <OutputType>Exe</OutputType>  
        <TargetFramework>net10.0</TargetFramework>  
        <PublishSingleFile>true</PublishSingleFile>  
        <SelfContained>true</SelfContained>  
        <RuntimeIdentifier>win-x64</RuntimeIdentifier>  
        <ImplicitUsings>disable</ImplicitUsings>  
        <Nullable>enable</Nullable>  
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>  
        <ApplicationIcon>main.ico</ApplicationIcon>  
        <Version>1.0.0</Version>  
        <Copyright>Copyright © 2026 devsight.kr</Copyright>  
        <!-- 복사 충돌 시 -->  
        <!-- <ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles> -->    </PropertyGroup>  
  
    <!-- managed 라이브러리 PublishSingleFile 빌드할 때 EXE에 포함하지 않음 -->  
    <ItemGroup>  
        <ProjectReference Include="..\ConsoleAppLib\ConsoleAppLib.csproj">  
            <ExcludeFromSingleFile>true</ExcludeFromSingleFile>  
        </ProjectReference>  
    </ItemGroup>  
  
    <!-- AOT 라이브러리 빌드 -->  
    <ItemGroup>  
        <ProjectReference Include="..\ConsoleAppNative\ConsoleAppNative.csproj" ReferenceOutputAssembly="false">  
            <ExcludeFromSingleFile>true</ExcludeFromSingleFile>  
        </ProjectReference>  
    </ItemGroup>  
  
    <PropertyGroup>  
        <AotDllSourcePath>..\ConsoleAppNative\bin\$(Configuration)\$(TargetFramework)\win-x64\publish\ConsoleAppNative.dll</AotDllSourcePath>  
    </PropertyGroup>  
  
    <Target Name="PublishNativeAotLibrary" BeforeTargets="BeforeBuild;ComputeFilesToPublish">  
        <Message Importance="High" Text="[AOT 빌드 시작] ConsoleAppNative 프로젝트를 네이티브 DLL로 게시(Publish) 중..."/>  
        <Exec Command="dotnet publish &quot;..\ConsoleAppNative\ConsoleAppNative.csproj&quot; -c $(Configuration) -r win-x64"              StdOutEncoding="utf-8" StdErrEncoding="utf-8"/>  
    </Target>  
  
    <Target Name="CopyAotDllForBuild" AfterTargets="PublishNativeAotLibrary" Condition="'$(PublishProtocol)' == ''">  
        <Message Importance="High" Text="[빌드 모드] 생성된 네이티브 DLL을 출력 폴더로 복사합니다."/>  
        <Copy SourceFiles="$(AotDllSourcePath)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true"/>  
    </Target>  
  
    <Target Name="ExcludeAotDllFromSingleFile" AfterTargets="PublishNativeAotLibrary" BeforeTargets="ComputeFilesToPublish">  
        <Message Importance="High" Text="[배포 모드] 네이티브 DLL을 단일 파일에서 제외하고 외부 배포 목록에 추가합니다."/>  
        <ItemGroup>  
            <ResolvedFileToPublish Include="$(AotDllSourcePath)">  
                <RelativePath>ConsoleAppNative.dll</RelativePath>  
                <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>  
                <ExcludeFromSingleFile>true</ExcludeFromSingleFile>  
            </ResolvedFileToPublish>  
        </ItemGroup>  
    </Target>  
  
    <ItemGroup>  
        <None Remove="main.ico"/>  
        <Resource Include="main.ico"/>  
    </ItemGroup>  
  
    <!-- 메인(ConsoleApp)프로젝트에 이미 포함되어 있을 때 -->  
    <ItemGroup>  
         <None Update="CppNative.dll">  
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>  
             <ExcludeFromSingleFile>true</ExcludeFromSingleFile>  
         </None>  
        <None Update="rust_native.dll">  
            <CopyToOutputDirectory>Always</CopyToOutputDirectory>  
            <ExcludeFromSingleFile>true</ExcludeFromSingleFile>  
        </None>  
        <None Update="zig_native.dll">  
            <CopyToOutputDirectory>Always</CopyToOutputDirectory>  
            <ExcludeFromSingleFile>true</ExcludeFromSingleFile>  
        </None>  
         <!--  
        <None Update="Database\test.db">
            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
        </None>
        -->
    </ItemGroup>  
</Project>

# 싱글 파일 배포
dotnet publish -c Release : csproj에서 설정한 경우
dotnet publish -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true  

C#에 사용된 전체 예제는 Github에서 확인할 수 있다. 폴더명은 csProject / ConsoleProject / 3개 프로젝트.

참고로 Zig 컴파일러는 아직 정식 버전으로 확정하기 전이므로 버전별로 호환에 문제가 발생할 수 있다.

C#에서 Function Pointer 사용하기

Fri, 10 Apr 2026 00:00:00 +0900

C#의 함수 포인터(Function Pointer)는 C# 9.0부터 도입된 기능으로, 고성능 연산이나 네이티브(C++, Delphi) 라이브러리와의 연동을 위해 만들어진 가장 로우레벨한 함수 호출 방식이다.

C++의 void (*func)(int)와 동일하게 함수의 주솟값을 직접(참조) 가리킨다. 메모리 주소를 직접 다루기 때문에 반드시 unsafe 키워드가 필요하다. csproj에서 AllowUnsafeBlock를 true로 설정한다.

Delegate나 Action 같은 객체를 생성하지 않으므로, 호출 시 가비지 컬렉터(GC) 오버헤드가 없고 CPU가 즉시 해당 주소로 점프하므로 제로 오버헤드로 볼 수 있다.

함수 포인터의 기본 문법은 delegate* 키워드를 사용하여 선언하며, 마지막 파라미터가 리턴 타입이 된다.

// 선언: <매개변수1, 매개변수2, 리턴타입>
delegate*<int, int, int> addPtr;

// 할당: & 연산자로 정적(static) 함수의 주소를 가져옴
addPtr = &MyStaticFunction;
  
// 호출: 일반 함수처럼 호출
int result = addPtr(10, 20);

// Program.cs
using System;  
  
namespace ConsoleApp;  
  
internal class Program  
{  
    private static void Main()  
    {  
        MathEngine math = new();  
        double resulMath = math.Execute(OpType.Divide, 3, 0);  
  
        if (double.IsNaN(resulMath))  
        {  
            Console.WriteLine($"Error: {resulMath}");  
        }  
        else  
        {  
            Console.WriteLine(resulMath);  
        }  
    }  
}

MathEngine.cs (Function Pointer)

namespace ConsoleApp;  
  
public unsafe class MathEngine  
{  
    private readonly delegate*<double, double, double>[] mOperationTable;
  
    public MathEngine()  
    {  
        mOperationTable = new delegate*<double, double, double>[4];  
        mOperationTable[(int)OpType.Add] = &Add;  
        mOperationTable[(int)OpType.Subtract] = &Subtract;  
        mOperationTable[(int)OpType.Multiply] = &Multiply;  
        mOperationTable[(int)OpType.Divide] = &Divide;  
    }  
  
    private static double Add(double a, double b) => a + b;  
  
    private static double Subtract(double a, double b) => a - b;  
  
    private static double Multiply(double a, double b) => a * b;  
  
    private static double Divide(double a, double b) => b != 0 ? a / b : double.NaN;
  
    public double Execute(OpType op, double a, double b)  
    {  
        int opIndex = (int)op;  
  
        if ((uint)opIndex >= (uint)mOperationTable.Length)  
        {  
            return 0;  
        }  
  
        delegate*<double, double, double> func = mOperationTable[opIndex];
        return func != null ? func(a, b) : 0;

        // if (func != null)
        // {
        //     return mOperationTable[opIndex](a, b);
        // }
        //
        // return 0;
    }  
}  
  
public enum OpType  
{  
    Add = 0,  
    Subtract = 1,  
    Multiply = 2,  
    Divide = 3  
}

Dictionary vs. Function Pointer

using System;  
using System.Collections.Generic;  
  
public class DictionaryExample  
{  
    private readonly Dictionary<string, Action<string>> mCommandMap = new();
  
    public DictionaryExample()  
    {  
        mCommandMap.Add("Print", (msg) => Console.WriteLine($"[Print] {msg}"));
        mCommandMap.Add("Log", ShowLog);  
    }  
  
    private static void ShowLog(string message)  
    {  
        Console.WriteLine($"[Log] {DateTime.Now}: {message}");  
    }  
  
    public void Execute(string commandName, string data)  
    {  
        if (mCommandMap.TryGetValue(commandName, out var action))  
        {  
            action(data);  
        }  
        else  
        {  
            Console.WriteLine("명령어를 찾을 수 없습니다.");  
        }  
    }  
}

using System;  
  
public unsafe class FunctionPointerExample  
{  
    private readonly delegate*<int, void>[] mFunctionTable;  
  
    public FunctionPointerExample()  
    {  
        mFunctionTable = new delegate*<int, void>[2];  
        mFunctionTable[0] = &DoubleValue;  
        mFunctionTable[1] = &SquareValue;  
    }  
  
    private static void DoubleValue(int x) => Console.WriteLine($"Double: {x * 2}");
  
    private static void SquareValue(int x) => Console.WriteLine($"Square: {x * x}");
  
    public void Execute(int index, int value)  
    {  
        if (index >= 0 && index < mFunctionTable.Length)  
        {  
            mFunctionTable[index](value);  
        }  
    }  
}

Dictionary는 Execute("Print", "Hello")와 같이 이름으로 호출하므로 코드가 직관적이지만 내부적으로 문자열 비교와 해시 계산이 발생한다. Function Pointer는 Execute(0, 10)와 같이 인덱스로 호출하므로 매우 빠르다.

CLion에서 Qt 개발환경 설정하기

Fri, 27 Mar 2026 00:00:00 +0900

Qt Framework를 사용할 때 개발툴로 Qt Creator를 사용하는데 이것을 대신하여 Jetbrains사의 C++ 개발 환경인 CLion을 이용하여 윈도 위젯을 만들 수 있다.

Qt는 기본으로 제공하며 여기에 CMakeLists.txt를 수정하여 개발 환경을 구축한다. 프로젝트를 생성하고 빌드하면 cmake 설정 에러가 날 수 있는데 cmake 파일을 수정하기 않아서이다.

graph LR
A["New Project"] --> B["Qt Widgets Excutable"]
B --> C["CMakeLists.txt"]
C --> D["Qt UI Class"]

추가로 프로그램 아이콘(타이틀바, 실행파일)을 설정한다.

CMakeLists.txt 툴체인 샘플

set(QT_ROOT_PATH "C:/Qt/6.8.3")  
set(MSYS2_UCRT_PATH "C:/msys64/ucrt64")

if (MSVC)
    set(CMAKE_PREFIX_PATH "${QT_ROOT_PATH}/msvc2022_64")
elseif (EXISTS "${MSYS2_UCRT_PATH}")
    list(APPEND CMAKE_PREFIX_PATH "${MSYS2_UCRT_PATH}")
    set(CMAKE_FIND_ROOT_PATH "${MSYS2_UCRT_PATH}")
else ()
    set(CMAKE_PREFIX_PATH "${QT_ROOT_PATH}/mingw_64")
endif ()

개발환경 : CLion 2025.3.4, Qt 6.8.3, 툴체인 MinGW/Visual Sutio

CMakeLists.txt 기본설정

cmake_minimum_required(VERSION 4.1)  
project(qtproject)  
  
set(QT_ROOT_PATH "C:/Qt/6.8.3")  
  
if (MSVC)  
    set(CMAKE_PREFIX_PATH "${QT_ROOT_PATH}/msvc2022_64")  
else ()  
    set(CMAKE_PREFIX_PATH "${QT_ROOT_PATH}/mingw_64")  
endif ()  
  
set(CMAKE_CXX_STANDARD 20)  
set(CMAKE_AUTOMOC ON)  
set(CMAKE_AUTORCC ON)  
set(CMAKE_AUTOUIC ON)  
  
find_package(Qt6 COMPONENTS Core Gui Widgets REQUIRED)  
  
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)  
  
set(CMAKE_AUTOUIC_SEARCH_PATHS  
        ${CMAKE_SOURCE_DIR}/ui  
        ${CMAKE_SOURCE_DIR}/src  
)  
  
add_executable(${PROJECT_NAME} main.cpp resources.qrc app.rc  
        src/mainwindow.cpp  
        include/mainwindow.h  
        ui/mainwindow.ui)  
  
target_include_directories(${PROJECT_NAME} PRIVATE  
        include  
        ${CMAKE_BINARY_DIR}  
)  
  
target_link_libraries(${PROJECT_NAME} Qt::Core Qt::Gui Qt::Widgets)

CMakeLists.txt 빌드 환경설정

위의 코드에 아래의 코드를 더하여 빌드 환경을 구축한다. 각 빌드 기본 폴더 안의 deploy 폴더에 배포 시 필요한 최소화된 파일들이 생성된다. MinGW, MSVC 같이 적용한 파일이다.

if (WIN32 AND NOT DEFINED CMAKE_TOOLCHAIN_FILE)  
    set_target_properties(${PROJECT_NAME} PROPERTIES WIN32_EXECUTABLE ON)  
  
    if (TARGET Qt6::qmake)  
        get_target_property(_qmake_executable Qt6::qmake IMPORTED_LOCATION)  
        get_filename_component(_qt_bin_dir "${_qmake_executable}" DIRECTORY)  
        find_program(WINDEPLOYQT_EXECUTABLE windeployqt HINTS "${_qt_bin_dir}")  
    endif ()  
  
    if (WINDEPLOYQT_EXECUTABLE)  
  
        set(DEPLOY_DIR "${CMAKE_BINARY_DIR}/deploy")  
  
        if (MSVC AND CMAKE_BUILD_TYPE STREQUAL "Debug")  
            set(DEPLOY_MODE "--debug")  
        else ()  
            set(DEPLOY_MODE "--release")  
        endif ()  
  
        set(MINIMIZE_FLAGS  
                "--no-translations"  
                "--no-opengl-sw"
                "--no-system-d3d-compiler"
                "--no-svg"
                "--no-quick-import"
                "--no-sql"
                "--no-network"
        )  
  
        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD  
                COMMAND "${WINDEPLOYQT_EXECUTABLE}"  
                ${DEPLOY_MODE}  
                --compiler-runtime  
                --no-translations  
                --verbose 0  
                "$<TARGET_FILE:${PROJECT_NAME}>"  
  
                COMMAND ${CMAKE_COMMAND} -E rm -rf "${DEPLOY_DIR}"  
                COMMAND ${CMAKE_COMMAND} -E make_directory "${DEPLOY_DIR}"  
  
                COMMAND ${CMAKE_COMMAND} -E copy  
                "$<TARGET_FILE:${PROJECT_NAME}>"  
                "${DEPLOY_DIR}/"  
  
                COMMAND "${WINDEPLOYQT_EXECUTABLE}"  
                ${DEPLOY_MODE}  
                --compiler-runtime  
                ${MINIMIZE_FLAGS}  
                --verbose 1  
                "${DEPLOY_DIR}/$<TARGET_FILE_NAME:${PROJECT_NAME}>"  
  
                COMMENT "build 실행 환경, deploy 최소 DLL 구성 완료"  
        )  
    endif ()  
endif ()

프로그램 아이콘 설정

cmake 파일의 add_executable 부분에 넣어준다. 예제에는 포함하였다.

app.rc

IDI_ICON1 ICON "main.ico"

resources.qrc

<RCC>  
    <qresource prefix="/">  
        <file>main.ico</file>  
    </qresource>
</RCC>

main.cpp

#include "mainwindow.h"
#include <QApplication>
#include <QScreen>
#include <QDebug>

int main(int argc, char *argv[]) {
    QApplication a(argc, argv);

    qDebug() << "현재 기기 픽셀 비율:" <<
            a.devicePixelRatio();
    qDebug() << "적용된 라운딩 정책:" <<
            QGuiApplication::highDpiScaleFactorRoundingPolicy();

    MainWindow m;
    m.show();
    return QApplication::exec();
}

mainwindow.h

#ifndef QTPROJECT_MAINWINDOW_H  
#define QTPROJECT_MAINWINDOW_H  
  
#include <QMainWindow>  
  
QT_BEGIN_NAMESPACE  
  
namespace Ui {  
    class MainWindow;  
}  
  
QT_END_NAMESPACE  
  
class MainWindow : public QMainWindow {  
    Q_OBJECT  
  
public:  
    explicit MainWindow(QWidget *parent = nullptr);  
  
    ~MainWindow() override;  
  
private:  
    Ui::MainWindow *ui;  
};  
  
#endif //QTPROJECT_MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"  
#include "ui_mainwindow.h" 
  
MainWindow::MainWindow(QWidget *parent)  
    : QMainWindow(parent), ui(new Ui::MainWindow) {  
    ui->setupUi(this);  
}  
  
MainWindow::~MainWindow() {  
    delete ui;  
}

main.cpp를 제외한 소스코드는 src,inclue,ui 폴더로 이동하여 작성한다. 코드 작성 후 reset cache and Reload project를 실행하여 설정이 꼬인 부분을 해결한다.

참고로 UI 파일을 클릭하면 Qt 설치 시 제공된 디자이너가 실행된다.

msys64/ucrt64 QT예제

cmake_minimum_required(VERSION 4.2)
project(msys2_qt)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_PREFIX_PATH "C:/msys64/ucrt64")

find_package(Qt6 REQUIRED COMPONENTS Core Sql)
find_package(SQLite3 REQUIRED)

add_executable(${PROJECT_NAME}
        main.cpp
        db_raii.h
)

target_link_libraries(${PROJECT_NAME} PRIVATE
        Qt6::Core
        Qt6::Sql
        SQLite::SQLite3
)

CMakeLists.txt 전체 내용 및 예제는 GitHub에서 확인할 수 있다.

C#에서 AOT로 NLog사용하기

Tue, 24 Mar 2026 00:00:00 +0900

이전 글 C# AOT 라이브러리 활용에 이어 이번 글에서는 로그 시스템으로 많이 사용하는 NLog를 AOT (Ahead-of-Time)로 빌드하여 라이브러리로 사용하는 법을 알아본다.

실행파일과 같은 폴더에 AppLogs 폴더를 만들고 여기에 연월/날짜/로그타입별파일로 기록하고 디버그 모드로 빌드 후 실행 했을때 DebugViewPP로 실시간 로그를 볼 수 있도록 하였다.

기본 패키지의 리플랙션(Reflection)¹을 피해서 작성해야 하므로 기본 사용법과 차이가 있을 수 있다. 참고로 Avalonia+SukiUi+MVVM로 구성된 프로젝트를 AOT로 빌드할 수 있도록 주요 패키지를 하나씩 옮겨보려고 한다.

LogHelper(AOT)

프로젝트(LogHelper) 구성

<Project Sdk="Microsoft.NET.Sdk">  
    <PropertyGroup>  
        <TargetFramework>net10.0</TargetFramework>  
        <ImplicitUsings>disable</ImplicitUsings>  
        <Nullable>enable</Nullable>  
        <PublishAot>true</PublishAot>  
        <IsAotCompatible>true</IsAotCompatible>  
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>  
        <OptimizationPreference>Speed</OptimizationPreference>  
    </PropertyGroup>  
  
    <ItemGroup>  
        <PackageReference Include="NLog" Version="6.1.1"/>  
        <PackageReference Include="NLog.OutputDebugString" Version="6.1.1"/>  
    </ItemGroup>  
  
    <Target Name="CopyLogHelperDebug" AfterTargets="Publish">  
        <Copy Condition="'$(Configuration)' == 'Debug'"  
              SourceFiles="$(PublishDir)LogHelper.dll"  
              DestinationFiles="$(PublishDir)LogHelper.Debug.dll"  
              SkipUnchangedFiles="true"/>  
        <Copy Condition="'$(Configuration)' == 'Release'"  
              SourceFiles="$(PublishDir)LogHelper.dll"  
              DestinationFiles="$(PublishDir)LogHelper.Release.dll"  
              SkipUnchangedFiles="true"/>  
    </Target>  
</Project>

소스 AOT(LogHelper.cs)

using NLog;
using NLog.Config;
using NLog.Targets;
using NLog.Targets.Wrappers;
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace LogHelper;

public static class LogHelper
{
    private static readonly Logger? _logger;

    private static readonly LogLevel[] _nLogLevels =
    [
        LogLevel.Trace,
        LogLevel.Info,
        LogLevel.Warn,
        LogLevel.Error,
        LogLevel.Fatal,
        LogLevel.Debug
    ];

    static LogHelper()
    {
        ISetupBuilder logFactory = LogManager.Setup().LoadConfiguration(builder =>
        {
            LoggingConfiguration config = builder.Configuration;
            const string layout =
                @"[${date:format=HH\:mm\:ss} ${level:uppercase=true:padding=5} : PID ${processid:Padding=5}] ${message} (${event-properties:File}::${event-properties:Member}[${event-properties:Line}][${threadid}])";

            builder.ForLogger().FilterMinLevel(LogLevel.Trace);
#if DEBUG
            OutputDebugStringTarget debugTarget = new("debug") { Layout = layout };
            LoggingRule debugRule = new("*", LogLevel.Trace, LogLevel.Fatal, debugTarget) { Final = false };
            config.LoggingRules.Add(debugRule);
#endif
            FileTarget fileTarget = new("FileTarget")
            {
                FileName = "${basedir}/AppLogs/${date:format=yyyyMM}/${date:format=dd}/${level}_${date:format=yyyyMMdd}.txt",
                Layout = layout,
                KeepFileOpen = true,
                MaxArchiveDays = 90
                // 선택사항
                ArchiveFileName = "${basedir}/AppLogs/${date:format=yyyyMM}/${date:format=dd}/${level}_${date:format=yyyyMMdd}.{#}.txt",
                ArchiveAboveSize = 10485760, // 10MB마다 새 파일 생성
                ArchiveEvery = FileArchivePeriod.Day
            };

            AsyncTargetWrapper asyncWrapper = new(fileTarget)
            {
                QueueLimit = 10000,
                OverflowAction = AsyncTargetWrapperOverflowAction.Discard,
                TimeToSleepBetweenBatches = 0
            };

            LoggingRule rule = new("*", LogLevel.Trace, LogLevel.Fatal, asyncWrapper) { Final = true };
            config.LoggingRules.Add(rule);
        });
        
        _logger = logFactory.GetLogger("NativeLogger");
    }

    [UnmanagedCallersOnly(EntryPoint = "LogWrite", CallConvs = [typeof(CallConvCdecl)])]
    public static void NativeLog_Write(int level, IntPtr msgPtr, IntPtr fileNamePtr, IntPtr memberPtr, int line)
    {
        try
        {
            LogLevel nLevel = (uint)level < (uint)_nLogLevels.Length ? _nLogLevels[level] : LogLevel.Trace;
            
            if (_logger != null && !_logger.IsEnabled(nLevel))
            {
                return;
            }

            if (msgPtr == IntPtr.Zero)
            {
                return;
            }
            
            string? msg = Marshal.PtrToStringUTF8(msgPtr);

            if (string.IsNullOrWhiteSpace(msg))
            {
                return;
            }

            string member = memberPtr != IntPtr.Zero ? Marshal.PtrToStringUTF8(memberPtr) ?? "Unknown" : "Unknown";
            string file = fileNamePtr != IntPtr.Zero ? GetFileNameWithoutExtension(fileNamePtr) : "Unknown";

            LogEventInfo logEvent = LogEventInfo.Create(nLevel, _logger?.Name, msg);
            logEvent.Properties["Member"] = member;
            logEvent.Properties["Line"] = line;
            logEvent.Properties["File"] = file;

            _logger?.Log(logEvent);
        }
        catch
        {
            // Native 영역으로 예외가 전파되지 않도록 차단 (Access Violation 방지)
        }
    }
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static unsafe string GetFileNameWithoutExtension(IntPtr ptr)
    {
        ReadOnlySpan<byte> utf8Span = MemoryMarshal.CreateReadOnlySpanFromNullTerminated((byte*)ptr);
        
        int lastSlash = utf8Span.LastIndexOf((byte)'\\');

        if (lastSlash == -1)
        {
            lastSlash = utf8Span.LastIndexOf((byte)'/');
        }

        if (lastSlash >= 0)
        {
            utf8Span = utf8Span[(lastSlash + 1)..];
        }
        
        int dot = utf8Span.LastIndexOf((byte)'.');

        if (dot >= 0)
        {
            utf8Span = utf8Span[..dot];
        }
        
        return System.Text.Encoding.UTF8.GetString(utf8Span);
    }
    
    [UnmanagedCallersOnly(EntryPoint = "LogShutdown")]
    public static void NativeLog_Shutdown()
    {
        try
        {
            LogManager.Flush(TimeSpan.FromSeconds(2));
            LogManager.Shutdown();
        }
        catch
        {
            // Native 영역으로 예외가 전파되지 않도록 차단
        }
    }
}

dotnet publish -r win-x64 -c Release, dotnet publish -r win-x64 -c Debug를 LogHelper.csproj 프로젝트 안에서 실행한 후 LogHelper.Release.dll, LogHelper.Debug.dll을 publish 폴더에서 복사하여 메인 프로그램에서 사용한다.

메인프로그램(콘솔)

프로젝트 구성(NativeTest)

<Project Sdk="Microsoft.NET.Sdk">  
    <PropertyGroup>  
        <OutputType>Exe</OutputType>  
        <TargetFramework>net10.0</TargetFramework>  
        <ImplicitUsings>disable</ImplicitUsings>  
        <Nullable>enable</Nullable>  
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>  
    </PropertyGroup>
    
    <!-- aot가 아닌 콘솔에서 테스트용도, aot만 불러오면 필요없음 -->  
    <ItemGroup>  
      <PackageReference Include="NLog" Version="6.1.1" />  
      <PackageReference Include="NLog.OutputDebugString" Version="6.1.1" />  
    </ItemGroup>  
</Project>

메인프로그램 소스(Program.cs)

using System;  
using System.Threading.Tasks;  
  
namespace NativeTest;  
  
internal class Program  
{  
    private static async Task Main()  
    {  
        LogHelper.Info("info");  
        LogHelper.Warn("Warn");  
        LogHelper.Error("Error");  
        LogHelper.Fatal("Fatal");  
        LogHelper.Debug("Debug");  
        LogHelper.Trace("Trace");  
              
        Console.WriteLine("헬로우월드");  
        Console.WriteLine("종료 중...");  
          
        bool isLogClose = await Task.Run(()=>  
        {  
            LogHelper.Shutdown();  
            return true;  
        });  
          
        Console.WriteLine(isLogClose ? "로그 Flush 완료" : "로그 Flush 에러");  
          
        Console.WriteLine("프로그램 종료");  
    }  
}

콘솔에서 사용하는 Helper클래스

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace NativeTest;

public partial class LogHelper
{
#if DEBUG
    private const string DLL_NAME = "LogHelper.Debug.dll";
#else
    private const string DLL_NAME = "LogHelper.Release.dll";
#endif

    private static readonly bool _isNativeLoaded;

    static LogHelper()
    {
        _isNativeLoaded = NativeLibrary.TryLoad(DLL_NAME, Assembly.GetExecutingAssembly(), null, out _);
    }

    private enum LogLevel
    {
        TRACE = 0,
        INFO = 1,
        WARN = 2,
        ERROR = 3,
        FATAL = 4,
        DEBUG = 5
    }

    [LibraryImport(DLL_NAME, EntryPoint = "LogWrite", StringMarshalling = StringMarshalling.Utf8)]
    private static partial void LogWrite(int level, string msg, string file, string member, int line);

    [LibraryImport(DLL_NAME, EntryPoint = "LogShutdown")]
    private static partial void LogShutdown();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static void Write(LogLevel level, string msg, string file, string member, int line)
    {
        if (!_isNativeLoaded)
        {
            return;
        }

        LogWrite((int)level, msg, file, member, line);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Trace(string msg, [CallerFilePath] string f = "", [CallerMemberName] string m = "", [CallerLineNumber] int l = 0)
        => Write(LogLevel.TRACE, msg, f, m, l);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Info(string msg, [CallerFilePath] string f = "", [CallerMemberName] string m = "", [CallerLineNumber] int l = 0)
        => Write(LogLevel.INFO, msg, f, m, l);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Warn(string msg, [CallerFilePath] string f = "", [CallerMemberName] string m = "", [CallerLineNumber] int l = 0)
        => Write(LogLevel.WARN, msg, f, m, l);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Error(string msg, [CallerFilePath] string f = "", [CallerMemberName] string m = "", [CallerLineNumber] int l = 0)
        => Write(LogLevel.ERROR, msg, f, m, l);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Fatal(string msg, [CallerFilePath] string f = "", [CallerMemberName] string m = "", [CallerLineNumber] int l = 0)
        => Write(LogLevel.FATAL, msg, f, m, l);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Debug(string msg, [CallerFilePath] string f = "", [CallerMemberName] string m = "", [CallerLineNumber] int l = 0)
        => Write(LogLevel.DEBUG, msg, f, m, l);

    public static void Shutdown()
    {
        if (!_isNativeLoaded)
        {
            return;
        }

        try
        {
            LogShutdown();
        }
        catch
        {
            // 종료 시의 예외는 무시해도 안전한 경우가 많음
        }
    }
}

위의 소스는 AOT의 LogHelper가 아니고 콘솔에서 라이브러리를 사용하기 위한 헬퍼클래스 이다. 이름이 같으므로 혼동하지 말 것.

AOT없이 않고 직접 NLog 사용하기

using NLog;
using NLog.Config;
using NLog.Targets;
using NLog.Targets.Wrappers;
using System;
using System.Runtime.CompilerServices;

namespace NativeTest;

public static class LogTest
{
    private static readonly Logger _logger;
    private const string EX = " >> ";

    static LogTest()
    {
        LoggingConfiguration config = new();

        const string common_layout =
            @"[${date:format=HH\:mm\:ss} ${level:uppercase=true:padding=5} : PID ${processid:Padding=5}] ${message}${onexception:${exception:format=message}} (${callsite:className=true:includeNamespace=false:methodName=true}[${callsite-linenumber}][${threadid}])";

        const string log_folder = "${basedir}/AppLogs/${date:format=yyyyMM}/${date:format=dd}";

        FileTarget fileTarget = new("FileTarget")
        {
            FileName = log_folder + "/${level}_${date:format=yyyyMMdd}.txt",
            ArchiveFileName = log_folder + "/${level}_${date:format=yyyyMMdd}.{#}.txt",
            Layout = common_layout,
            Encoding = System.Text.Encoding.UTF8,
            KeepFileOpen = true,
            OpenFileCacheTimeout = 30,
            AutoFlush = false,
            BufferSize = 65536,
            ArchiveEvery = FileArchivePeriod.Day,
            MaxArchiveDays = 90,
            ArchiveAboveSize = 10485760
        };

        AsyncTargetWrapper asyncWrapper = new(fileTarget, 10000, AsyncTargetWrapperOverflowAction.Grow)
        {
            TimeToSleepBetweenBatches = 0
        };

        config.AddRule(LogLevel.Trace, LogLevel.Fatal, asyncWrapper);

#if DEBUG
        OutputDebugStringTarget debugOutput = new("debugOutput")
        {
            Layout = common_layout
        };
        AsyncTargetWrapper asyncDebug = new(debugOutput, 5000, AsyncTargetWrapperOverflowAction.Discard);
        config.AddRule(LogLevel.Trace, LogLevel.Fatal, asyncDebug);
#endif

        LogManager.Configuration = config;
        _logger = LogManager.GetCurrentClassLogger();
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static void WriteLog(LogLevel level, string message, Exception? ex = null)
    {
        if (!_logger.IsEnabled(level))
        {
            return;
        }

        try
        {
            LogEventInfo logEvent = new(level, _logger.Name, message)
            {
                Exception = ex
            };

            _logger.Log(typeof(LogTest), logEvent);
        }
        catch
        {
            // ignored
        }
    }

    public static void Trace(string msg) => WriteLog(LogLevel.Trace, msg);

    public static void Debug(string msg) => WriteLog(LogLevel.Debug, msg);

    public static void Info(string msg) => WriteLog(LogLevel.Info, msg);

    public static void Warn(string msg) => WriteLog(LogLevel.Warn, msg);

    public static void Error(string msg) => WriteLog(LogLevel.Error, msg);

    public static void Error(Exception ex, string msg) => WriteLog(LogLevel.Error, msg + EX, ex);

    public static void Fatal(string msg) => WriteLog(LogLevel.Fatal, msg);

    public static void Fatal(Exception ex, string msg) => WriteLog(LogLevel.Fatal, msg + EX, ex);

    public static void Shutdown()
    {
        try
        {
            LogManager.Flush(TimeSpan.FromSeconds(2));
            LogManager.Shutdown();
        }
        catch
        {
            // ignored
        }
    }
}

위의 소스는 AOT가 아닌 프로젝트에서 바로 NLog를 사용할 때 필요한 소스코드이고 LogTest.Error("Error"); 또는 LogTest.Error(ex, "Error"); 형태로 필요한 곳에서 바로 사용한다. 즉, AOT용 하나, 메인에서 바로 사용하는 파일 하나 이렇게 2개로 예제를 작성한 것이다.

애플케애션 설정(App.axml.cs)

public partial class App : Application  
{  
    protected override void OnStartup(StartupEventArgs e)  
    {  
        base.OnStartup(e);  
  
        // UI 스레드 예외  
        this.DispatcherUnhandledException += (s, args) =>  
        {  
            LogHelper.Critical($"[UI Error] {args.Exception.Message}\n{args.Exception.StackTrace}");  
            args.Handled = true; // 에러메시지 후 앱은 실행  
        };  
          
        //작업 스레드 및 도메인 예외(task.run)  
        AppDomain.CurrentDomain.UnhandledException += (s, args) =>  
        {  
            if (args.ExceptionObject is Exception ex)  
            {  
                LogHelper.Fatal($"[Fatal Error] {ex.Message}\n{ex.StackTrace}");  
            }  
  
            LogHelper.Shutdown();  
        };  
        
        // 비동기 Task 예외(await없는 task)        
        TaskScheduler.UnobservedTaskException += (s, args) =>  
        {  
            LogHelper.Error($"[Async Error] {args.Exception.Message}");  
            args.SetObserved(); // 앱 종료 방지  
        };  
    }  
	
	// private static async void OnClosing(object? sender, CancelEventArgs e)
    protected override void OnExit(ExitEventArgs e)  
    {  
        LogHelper.Shutdown();  
        base.OnExit(e);  
    }  
}

이 부분은 프로그램 만들 때 필수로 처리해야 하는 코드의 예이다.

Reference

C#에서 리플랙션(Reflection)은 실행 중(Runtime)에 객체의 형식(Type), 메서드, 필드, 프로퍼티 등의 메타데이터를 조사하거나 조작할 수 있게 해주는 기능인데 컴파일 시점에 실행될 코드를 예측할 수 없어서 AOT에서는 피해야 하며 소스 생성기(Source Generators)를 통하여 빌드될 수 있도록 해야 한다. 주로 partial 키워드와 필요한 객체 위에 Attribute를 사용한다.

C# AOT 라이브러리 활용

Sun, 22 Mar 2026 00:00:00 +0900

C#은 관리형 언어(Managed Language)이다. 개발자가 메모리 할당과 해제를 하는 것을 CLR(런타임 환경)이 이를 대신해 주고 가비지 컬렉션(Garbage Collection)으로 사용하지 않는 메모리를 시스템이 자동으로 회수하여 메모리 누수를 방지한다.

대신에 빌드하면 소스코드가 바로 기계어로 바뀌는 것이 아니라 중간 언어(IL, Intermediate Language)로 컴파일된 실행 시점에 JIT(Just-In-Time)에 의해 기계어로 번역된다. 그래서 파일(exe, dll)을 ILSpy 같은 툴로 보면 소스코드가 훤히 보여 중요한 문자열을 숨기지 못하는 단점이 있다.

C#의 AOT(Ahead-of-Time) 컴파일은 애플리케이션을 실행하기 전(빌드 시점)에 코드를 해당 운영체제와 CPU가 이해할 수 있는 네이티브 기계어로 미리 번역해 두는 기술이다. 이것 때문에 이를 활용하면 ILSpy툴로 내용(소스)을 볼 수 없다. 다만 문자열은 헥사에니터 같은것으로 충분히 볼 수 있기 때문에 이를 보완해야 한다.

C++ constexpr, zig comptime, rust의 매크로함수인 obfstr!함수를 이용하여 컴파일 타임에 문자열을 난독화한다. 여기에서는 AOT만을 이용하여 기본을 학습한 후 이것을 토대로 zig, rust, c++를 라이브러리로 만들어 c#에서 활용해 보려고 한다.

AOT 라이브러리

프로젝트(NativeTestLib) 구성

<Project Sdk="Microsoft.NET.Sdk">  
    <PropertyGroup>  
        <TargetFramework>net10.0</TargetFramework>  
        <ImplicitUsings>disable</ImplicitUsings>  
        <Nullable>enable</Nullable>  
        <PublishAot>true</PublishAot>  
        <IsAotCompatible>true</IsAotCompatible>  
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>  
    </PropertyGroup>  
</Project>

소스(NativeTestLib.cs)

using System.Runtime.CompilerServices;  
using System.Runtime.InteropServices;  
  
namespace NativeTestLib;  
  
public static class NativeMain  
{  
    private static readonly byte[] _encryptedData =  
    [  
        0xBA, 0xCF, 0xF5, 0xB1, 0xFA, 0xC0, 0xB1, 0xC4, 0xEF, 0x8C, 0xFA, 0xF6, 0x88,  
        0xF7, 0xF9, 0x4B, 0x34, 0x0D, 0x0A, 0x1F, 0x19, 0x09, 0x29, 0x0F, 0x1B, 0x11  
    ];  
  
    private const byte BASE_KEY = 0x57;  
  
    [UnmanagedCallersOnly(EntryPoint = "GetSecureData")]  
    public static unsafe int GetSecureData(byte* buffer, int bufferLen)  
    {  
        try  
        {  
            int dataLen = _encryptedData.Length;  
  
            if (buffer == null)  
            {  
                return dataLen;  
            }  
  
            if (bufferLen < dataLen)  
            {  
                return -1;  
            }  
  
            for (int i = 0; i < dataLen; i++)  
            {  
                buffer[i] = DecryptByte(_encryptedData[i], i);  
            }  
  
            return dataLen;  
        }  
        catch  
        {  
            return -2;  
        }  
    }  
  
    [MethodImpl(MethodImplOptions.AggressiveInlining)]  
    private static byte DecryptByte(byte b, int index)  
    {  
        return (byte)(b ^ (BASE_KEY + index));  
    }  
}

작성 후 NativeTestLib.csproj에서 dotnet publish -r win-x64 -c Release를 실행하면 publish 폴더에 NativeTestLib.dll 이 만들어지는데 이 파일을 메인 프로그램에서 사용한다. 참고로 여기에 소스는 unsafe 블록으로 포인터 개념을 사용한다.

메인 프로그램

프로젝트 구성(NativeTest)

<Project Sdk="Microsoft.NET.Sdk">  
    <PropertyGroup>  
        <OutputType>Exe</OutputType>  
        <TargetFramework>net10.0</TargetFramework>  
        <ImplicitUsings>disable</ImplicitUsings>  
        <Nullable>enable</Nullable>  
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>  
    </PropertyGroup>  
  
    <PropertyGroup>  
        <RuntimeIdentifier Condition="'$(RuntimeIdentifier)' == ''">win-x64</RuntimeIdentifier>  
    </PropertyGroup>  
  
    <ItemGroup>  
        <None Include="..\NativeTestLib\bin\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\publish\NativeTestLib.dll">  
            <Link>NativeTestLib.dll</Link>  
            <CopyToOutputDirectory>Always</CopyToOutputDirectory>  
        </None>  
    </ItemGroup>  
</Project>

아이템 그룹으로 설정하면 되는데 동작이 안 될 때는 라이브러리(dll) 파일을 실행파일 있는 곳에 복사하여 사용한다.

메인프로그램 소스(Program.cs)

using System;  
using System.Runtime.InteropServices;  
using System.Text;  
using System.Threading.Tasks;  
  
namespace NativeTest;  
  
internal partial class Program  
{  
    [LibraryImport("NativeTestLib.dll", EntryPoint = "GetSecureData", StringMarshalling = StringMarshalling.Utf8)]  
    private static partial int GetSecureData(ref byte buffer, int bufferLen);  
  
    [LibraryImport("NativeTestLib.dll", EntryPoint = "GetSecureData", StringMarshalling = StringMarshalling.Utf8)]  
    private static partial int GetSize(IntPtr buffer, int bufferLen);  
  
    private static async Task<string> FetchSecureStringAsync()  
    {  
        try  
        {  
            return await Task.Run(() =>  
            {  
                int requiredSize = GetSize(IntPtr.Zero, 0);  
  
                if (requiredSize <= 0)  
                {  
                    return string.Empty;  
                }  
  
                Span<byte> buffer = stackalloc byte[requiredSize];  
                int actualLen = GetSecureData(ref MemoryMarshal.GetReference(buffer), buffer.Length);  
  
                if (actualLen <= 0)  
                {  
                    return string.Empty;  
                }  
  
                string result = Encoding.UTF8.GetString(buffer[..actualLen]);  
                buffer.Clear();  
                return result;  
            });  
        }  
        catch (DllNotFoundException ex)  
        {  
            Console.WriteLine($"NotFound: {ex.Message}");  
            return string.Empty;  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine($"Exception: {ex.Message}");  
            return string.Empty;  
        }  
    }  
  
    private static async Task Main()  
    {  
        const string str = "헬로우월드-SecureData";  
        string temp = Helper.GenerateXorHex(str);  
        Helper.Clipboard(temp);  
        Console.WriteLine(temp);  
  
        string secureKey = await FetchSecureStringAsync();  
        Console.WriteLine(string.IsNullOrWhiteSpace(secureKey) ? "데이터없음" : secureKey);  
    }  
}

위의 소스 중 아래의 소스는 실제 프로젝트에 포함하지 말아야 한다. Helper.cs파일도 마찬가지. 난독화한 바이트 배열을 만들고 이것을 AOT 라이브러리 소스에 복사하여 사용한다.

const string str = "헬로우월드-SecureData";  
string temp = Helper.GenerateXorHex(str);  
Helper.Clipboard(temp);  
Console.WriteLine(temp);  

Helper 클래스

메인에서 사용하는 Helper.cs

using System;  
using System.Diagnostics;  
using System.Text;  
  
namespace NativeTest;  
  
public class Helper  
{  
    public static string GenerateXorHex(string plainText, byte baseKey = 0x57)  
    {  
        byte[] bytes = Encoding.UTF8.GetBytes(plainText);  
        StringBuilder hexBuilder = new();  
  
        hexBuilder.AppendLine($"원본 문자열: {plainText}");  
        hexBuilder.Append("private static readonly byte[] EncryptedData = { ");  
  
        for (int i = 0; i < bytes.Length; i++)  
        {  
            // 가변 XOR 적용: (원본 바이트) ^ (기본키 + 인덱스)  
            byte encoded = (byte)(bytes[i] ^ (baseKey + i));  
  
            hexBuilder.Append($"0x{encoded:X2}");  
  
            if (i < bytes.Length - 1)  
                hexBuilder.Append(", ");  
        }  
  
        hexBuilder.Append(" };");  
  
        return hexBuilder.ToString();  
    }  
  
    public static void Clipboard(string text)  
    {  
        if (string.IsNullOrWhiteSpace(text))  
        {  
            return;  
        }  
  
        string base64Text = Convert.ToBase64String(Encoding.Unicode.GetBytes(text));  
        string script = $"[System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String('{base64Text}')) | Set-Clipboard";  
  
        using Process process = new();  
        process.StartInfo.FileName = "powershell";  
        process.StartInfo.Arguments = $"-NoProfile -ExecutionPolicy Bypass -Command \"{script}\"";  
        process.StartInfo.CreateNoWindow = true;  
        process.StartInfo.UseShellExecute = false;  
  
        process.Start();  
        process.WaitForExit();  
    }  
}

클립보드 함수는 복사 붙여넣기를 바로 하기 위하여 포함하였다 암튼 이 helper 클래스는 실제 프로젝트에는 배포 시 제외해야 한다.

이것으로 AOT를 이용하여 간단한 문자열 숨김을 해보았다. 실무에서는 더 복잡하게 작성해야 하는데 이 부분은 다음 글 작성 시 zig, rust, c++로 라이브러리를 만들어 c#에서 호출해 볼 것이다. 바로 호출하기 보다는 중간에 AOT를 매개로 연결한다. 참고로 AOT로 빌드한 네이티브 파일도 GC의 영향을 받는다.

Rust Web Frameworks 비교

Wed, 03 Sep 2025 00:00:00 +0900

Rust는 dotnet(C#)에 비해 성능이 우수하다고 알려져 있다.¹ 대표적인 Rust의 Web Frameworks에는 대표적으로 Actix Web, Rocket, Warp, Axum, Poem 등이 있는데 각각의 특징을 간략하게 예제(Axum)와 더불어 정리하였다.

학습에 도움이 될 만한 youtube 강좌

TechEmpower 벤치마크 결과 (Round 21)

프레임워크	언어	요청/초	지연시간(ms)	CPU 사용률
Actix-web (Rust)	Rust	748,051	1.7	98%
Axum (Rust)	Rust	723,892	1.8	97%
ASP.NET Core	C#	692,345	2.1	95%
Spring Boot	Java	153,846	6.5	92%
Express.js	Node.js	58,824	17.0	85%

dotNET의 경우 Rust에 비해 떨어지지 않는 성능을 보여준다.

Rust Web Framework vs. .NET WebAPI 성능 비교²

항목	Rust Web Framework	.NET WebAPI
동시 처리	매우 우수. Rust의 zero-cost abstraction과 안전한 메모리 모델 덕분에 수천~수만 동시 연결 처리 가능	Kestrel 서버 기반의 .NET Core도 수천 동시 연결 가능. 스레드풀과 async/await로 효율적 처리
동시성	Rust는 기본적으로 데이터 레이스를 방지. Send/Sync 트레이트로 안전하게 동시성 구현	.NET도 스레드 안전성 제공. Task 기반 비동기 모델로 동시성 구현. 그러나 메모리 리스크는 비교적 높음
비동기 처리	async/await, non-blocking IO, Tokio/async-std 등 강력한 지원	async/await, non-blocking IO, 스레드풀 기반 비동기 처리 지원
성능 벤치마크	Actix Web 기준: wrk, techempower benchmarks에서 가장 빠른 성능 자주 기록 (수백만 req/s)	ASP.NET Core: wrk, techempower benchmarks에서 상위권. Rust보다 약간 낮거나 비슷한 수준
메모리 사용량	매우 낮음. Rust의 ownership 시스템 덕분에 GC 오버헤드 없음	GC 기반이라 Rust보다 메모리 사용량 많음. 하지만 최적화로 많이 개선됨
안정성	컴파일 타임에 대부분의 오류 검출. 런타임 오류 적음	런타임에서 오류 발견 가능성 더 있음. C# 타입 시스템으로 어느 정도 방지
커뮤니티/생태계	안정적이고 빠르게 성장 중. 크지는 않음	매우 크고 성숙. 다양한 라이브러리와 툴링 지원

기술적 차이점의 요인으로 ‘메모리 관리’, ‘동시성 모델’, ‘네트워킹 스택’을 보면 Rust가 dotNET에 비해 상당히 성능이 우수하다. 그러나 극한의 성능과 안정성보다 생산성, 툴링, 윈도우/엔터프라이즈 환경친화성이 우선이라면 dotNET WebAPI가 더 우수하다고 볼 수 있다.

Rust 프레임워크 비교³

프레임워크	주된 특징	성능	사용 편의성	에코시스템 / 확장성
Actix Web	매우 높은 성능, Actor 기반 아키텍처, WebSocket 및 다양한 기능 내장	최상위권 (최고 처리량, 낮은 레이턴시)	다소 복잡 (액터 모델, 매크로 활용 등)	가장 성숙하고 확장성 높은 생태계 (ORM, 인증, 미들웨어 등)
Rocket	간결하고 타입 안전한 라우팅, Request Guards, Fairings(미들웨어)	좋은 성능, Actix에는 약간 밀림	초보자에게 매우 친숙한 API, 매크로 기반으로 간단	점진적으로 성장 중, 폼 처리 및 DB 등의 지원도 증가 중
Warp	필터 기반의 컴포저형 설계, 하이퍼 기반, 매우 유연함	가볍고 빠름, 오버헤드 최소화	필터 체이닝이 직관적이지만 초기 학습 곡선 존재	에코시스템은 작지만 비동기 유틸리티 중심으로 확장 중
Axum	Tokio + Hyper + Tower 기반, macro-free, 라우터 중심 설계	강력한 비동기 성능, 높은 처리량	직관적이고 러스트 초심자에게도 친숙한 API	빠르게 성장 중인 생태계, 웹 관련 크레이트 늘어남
Poem	간결하고 쉬운 사용성, minimalism 지향	빠름 (경량 기반), 규모에 따라 다름	단순하고 배우기 쉬움, 복잡 기능은 외부 크레이트 사용 필요	초기 단계지만 성장 중이고 커뮤니티 활성화 중

사용하기 쉽고 성능에 최적화된 비동기 프레임워크는 Axum이라고 볼 수 있다.

비동기 특화: Tokio + Hyper + Tower 기반 → async/await 친화적
성능: Actix Web과 큰 차이 없는 높은 처리량, 낮은 레이턴시
사용 편의성: 매크로 대신 함수/라우터 기반 API → 러스트 초보자도 직관적으로 사용 가능
에코시스템: Tower 미들웨어, tokio 생태계와 완벽 호환 → 확장성 뛰어남
현대적 설계: 최근 Rust async 웹 개발의 사실상 표준으로 자리잡는 추세

Axum 예제

# Cargo.toml
[package]  
name = "hello"  
version = "0.1.0"  
edition = "2024"  
  
[dependencies]  
axum = "0.8.1"  
tokio = { version = "1.47.1", features = ["full"] }  
serde = { version = "1.0.219", features = ["derive"] }  
serde_json = "1"  
http = "1.3.1"

// main.rs
use axum::{  
    extract::Json,  
    http::StatusCode,  
    response::IntoResponse,  
    routing::post,  
    Router,  
};  
use serde::{Deserialize, Serialize};  
use std::net::SocketAddr;  
use tokio::time::{sleep, Duration};  
  
#[derive(Serialize)]  
struct User {  
    id: u32,  
    name: String,  
}  
  
#[derive(Serialize)]  
struct ErrorResponse {  
    error: String,  
}  
  
#[derive(Deserialize)]  
struct UserRequest {  
    id: u32,  
}  
  
async fn root() -> impl IntoResponse {  
    Json(serde_json::json!({"message": "Hello, World!"}))  
}  
  
async fn get_user(Json(req): Json<UserRequest>) -> impl IntoResponse {  
    // DB 조회 (비동기 처리) 가정  
    sleep(Duration::from_millis(300)).await;  
  
    if req.id == 0 {  
        let err = ErrorResponse {  
            error: "User not found".to_string(),  
        };  
        (StatusCode::NOT_FOUND, Json(err)).into_response()  
    } else {  
        let user = User {  
            id: req.id,  
            name: format!("User{}", req.id),  
        };  
        (StatusCode::OK, Json(user)).into_response()  
    }  
}  
  
#[tokio::main]  
async fn main() {  
    let app = Router::new()  
        .route("/", post(root))  
        .route("/users", post(get_user));  
  
    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));  
    println!("Server listening on {}", addr);  
  
    if let Err(e) = axum::serve(tokio::net::TcpListener::bind(addr).await.unwrap(), app).await {  
        eprintln!("server error: {e:?}");  
    }  
}

예제 테스트

# root API
curl -X POST http://localhost:3000/
# {"message":"Hello, World!"}

# User조회 API(정상)
curl -X POST http://localhost:3000/users -H "Content-Type: application/json" -d "{\"id\": 1}"
# {"id":1,"name":"User1"}

# User조회 API(없음)
curl -X POST http://localhost:3000/users -H "Content-Type: application/json" -d "{\"id\": 0}"
# {"error":"User not found"}

Reference

techempower.com, “TechEmpower Benchmarks”

Github Copilot, https://dev.to/leapcell/rust-web-frameworks-compared-actix-vs-axum-vs-rocket-4bad 기반

ChatGPT, https://dev.to/leapcell/rust-web-frameworks-compared-actix-vs-axum-vs-rocket-4bad 기반

Free the memory used by a collection

Fri, 24 Jan 2025 00:00:00 +0900

C# .NET은 Managed Code이다. .NET의 구성요소인 CLR(Common Language Runtime)에서 실행되는 코드 유형이다. 상대적으로 Unmanaged Code는 CLR의 개입 없이 운영체제나 하드웨어에서 직접 실행되는 코드 유형이다. C#보다 머신 수준에 더 가까운 C, C++ 와 같은 언어로 작성된다.¹

Managed Code인 C#은 런타임 환경에서 자동으로 메모리 관리(GC, Garbage Collection)를 관리한다. IDisposable을 구현하는 개체를 사용할 때 using StreamReader와 같이 사용하면 함수의 블록이 끝날 때 자동으로 메모리에서 개체를 메모리에서 해제한다.²

간혹 개발자 중에 직접 메모리를 해제하고자 할 때 아래와 같이 코드를 작성하곤 하는 데 이러한 방법은 GC를 오해한 까닭에서 나온 결과이다.³

개선 전 코드

public static void ClearMemory<T>(this List<T> list)
{
    int id = GC.GetGeneration(list);
    list.Clear();
    GC.Collect(id, GCCollectionMode.Forced);
}

GC.Collect()를 호출하면 가비지 컬렉션이 실행될 가능성을 높이지만 Unmanaged 언어와 같이 바로 메모리가 반환되는 것을 보장하지 않는다. 즉, 힌트를 준 정도의 역할만 할 뿐이고 특히 GC를 자주 호출하면 CPU 시간을 소모하는 작업이기 때문에 오히려 성능에 악영향을 미칠 수 있다.

아래의 예제는 권장하는 코드와 함께 공부 차원에서 직접 작성한 몇 가지 클래스이다.

권장하는 코드

public static void ClearAll<T>(this List<T> list)  
{  
    list.Clear();  
    list.Capacity = 0;
    // 또는 단순하게 list = null; 참조가 없다고 알림
}

위에서처럼 Clear()를 사용하여 리스트가 차지하고 있던 메모리 공간을 가비지 컬렉션의 대상이 되게 한다. 그리고 Capacity = 0을 적용하여 리스트가 내부적으로 가지고 있는 배열의 메모리도 가비지 컬렉션의 대상이 되게 한다. 닷넷에서는 이렇게 하여 자동으로 GC가 일어나도록 힌트를 줄 수 있다. 나머지는 .NET이 알아서 자동 처리한다.

확장 함수 구현

Disposable한 컬렉션은 DisposeAll()을 사용하고 그렇지 않은 개체는 ClearAll()을 사용한다.

public static class DisposableExtensions  
{  
    public static void DisposeAll<T>(this List<T> list) where T : IDisposable  
    {  
        list.ForIn(x => x.Dispose());  
    }  
  
    public static void DisposeAll<T>(this T[] array) where T : IDisposable  
    {  
        array.ForIn(x => x.Dispose());  
    }  
  
    public static void DisposeAll<T>(this IEnumerable<T> collection) where T : IDisposable  
    {  
        collection.ForIn(x => x.Dispose());  
    }  
  
    public static void ClearAll<T>(this List<T> list)  
    {  
        list.Clear();  
        list.Capacity = 0;  
    }  
  
    private static void ForIn<T>(this IEnumerable<T>? seq, Action<T> act) where T : IDisposable  
    {  
        if (seq == null)  
        {  
            return;  
        }  
  
        List<Exception> exceptions = [];  
  
        foreach (T item in seq)  
        {  
            try  
            {  
                act(item);  
            }  
            catch (Exception ex)  
            {  
                exceptions.Add(ex);  
            }  
        }  
  
        if (exceptions.Count > 0)  
        {  
            throw new AggregateException($"Disposing Item ERROR : {exceptions}");  
        }  
    }  
}

IDisposable 패턴 적용

public sealed class DisposeList<T> : List<T>, IDisposable  
{  
    private bool mDisposedValue;  
  
    private void Dispose(bool disposing)  
    {  
        if (mDisposedValue)  
        {  
            return;  
        }  
  
        if (disposing)  
        {  
            foreach (IDisposable item in this.OfType<IDisposable>())  
            {  
                try  
                {  
                    item.Dispose();  
                }  
                catch (Exception ex)  
                {  
                    LogHelper.Logger.Error($"Disposing Item ERROR : {ex.Message}");  
                }  
            }  
  
            Clear();  
            Capacity = 0;  
        }  
  
        mDisposedValue = true;  
    }  
  
    ~DisposeList() => Dispose(false);  
  
    public void Dispose()  
    {  
        Dispose(disposing: true);  
        GC.SuppressFinalize(this);  
    }  
}

public sealed class DisposeArray<T>(uint initialLength = 0) : IDisposable  
{  
    private T[]? mArray = initialLength > 0 ? new T[initialLength] : null;  
    private bool mDisposedValue;  
  
    public T this[int index]  
    {  
        get  
        {  
            ObjectDisposedException.ThrowIf(mDisposedValue, nameof(DisposeArray<T>));  
  
            if (mArray == null || index < 0 || index >= Count)  
            {  
                throw new IndexOutOfRangeException();  
            }  
  
            return mArray[index];  
        }  
        set  
        {  
            ObjectDisposedException.ThrowIf(mDisposedValue, nameof(DisposeArray<T>));  
  
            if (index < 0)  
            {  
                throw new IndexOutOfRangeException();  
            }  
  
            if (mArray == null)  
            {  
                mArray = new T[Math.Max(index + 1, 4)];  
            }  
            else if (index >= mArray.Length)  
            {  
                Array.Resize(ref mArray, Math.Max(index + 1, mArray.Length * 2));  
            }  
  
            mArray[index] = value;  
            Count = Math.Max(Count, index + 1);  
        }  
    }  
  
    public int Count { get; private set; }  
  
    public int Capacity  
    {  
        get => mArray?.Length ?? 0;  
    }  
  
    public T[] ToArray()  
    {  
        ObjectDisposedException.ThrowIf(mDisposedValue, nameof(DisposeArray<T>));  
  
        if (mArray == null || Count == 0)  
        {  
            return [];  
        }  
  
        T[] newArray = new T[Count];  
        Array.Copy(mArray, newArray, Count);  
        return newArray;  
    }  
  
    public void Clear()  
    {  
        ObjectDisposedException.ThrowIf(mDisposedValue, nameof(DisposeArray<T>));  
  
        if (mArray != null)  
        {  
            Array.Clear(mArray, 0, mArray.Length);  
        }  
  
        Count = 0;  
    }  
  
    private void Dispose(bool disposing)  
    {  
        if (mDisposedValue) return;  
  
        if (disposing)  
        {  
            if (typeof(IDisposable).IsAssignableFrom(typeof(T)) && mArray != null)  
            {  
                List<Exception> exceptions = [];  
  
                foreach (IDisposable item in mArray.OfType<IDisposable>())  
                {  
                    try  
                    {  
                        item.Dispose();  
                    }  
                    catch (Exception ex)  
                    {  
                        exceptions.Add(ex);  
                    }  
                }  
  
                if (exceptions.Count != 0)  
                {  
                    throw new AggregateException($"Disposing Item ERROR : {exceptions}");  
                }  
            }  
            else  
            {  
                mArray = null;  
            }  
        }  
  
        mDisposedValue = true;  
    }  
  
    ~DisposeArray() => Dispose(false);  
  
    public void Dispose()  
    {  
        Dispose(true);  
        GC.SuppressFinalize(this);  
    }  
}

// 사용 예제
using DisposeList<string> comList = [];  
using DisposeArray<string> comArray = new(10); //완벽하지 않지만 동적 배열 가능

위의 클래스는 ‘확장 함수 구현’에서 보여준 것을 IDisposable 패턴을 적용하여 자동으로 처리하도록 구현하였다. 굳이 이렇게 사용할 필요는 없고 Clear(), Capacity = 0으로 충분하며, 당연하지만 StreamReader, Network의 Connection과 같이 IDisposable이 적용된 개체는 using을 사용해야 한다.

참고로 위에서 직접 작성한 소스를 deepseek에 질문했더니 아래와 같은 답변을 해주었다. 비교해서 학습하는 데 도움이 되길 바라면서 소스코드를 아래에 옮겨본다. 옮기는 과정에서 약간의 소스 추가(IEnumerable<T>,GetEnumerator 관련)및 정리는 하였다.

// 사용 예제
// List
using DisposeList<string> comList = new();
using DisposeList<string> comList = [];  
// Array
using DisposeArray<string> comList = new(10);  
using DisposeArray<string> comList = new();

public sealed class DisposeList<T> : IDisposable, IEnumerable<T>  
{  
    private readonly List<T> mList = [];  
    private bool mDisposedValue;  
  
    public T this[int index]  
    {  
        get => mList[index];  
        set => mList[index] = value;  
    }  
  
    public int Count  
    {  
        get => mList.Count;  
    }  
  
    public int Capacity  
    {  
        get => mList.Capacity;  
    }  
  
    public void Add(T item) => mList.Add(item);  
  
    public bool Remove(T item) => mList.Remove(item);  
  
    public void Clear() => mList.Clear();

    public IEnumerator<T> GetEnumerator() => mList.GetEnumerator();

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
  
    private void Dispose(bool disposing)  
    {  
        if (mDisposedValue) return;  
  
        if (disposing)  
        {  
            List<Exception> exceptions = [];  
  
            foreach (T item in mList)  
            {  
                if (item is not IDisposable disposable)  
                {  
                    continue;  
                }  
  
                try  
                {  
                    disposable.Dispose();  
                }  
                catch (Exception ex)  
                {  
                    exceptions.Add(ex);  
                }  
            }  
  
            if (exceptions.Count > 0)  
            {  
                throw new AggregateException("DisposeList disposal failed", exceptions);  
            }  
  
            mList.Clear();  
        }  
  
        mDisposedValue = true;  
    }  
  
    ~DisposeList() => Dispose(false);  
  
    public void Dispose()  
    {  
        Dispose(true);  
        GC.SuppressFinalize(this);  
    }  
}

public sealed class DisposeArray<T> : IDisposable  
{  
    private T[]? mArray;  
    private bool mDisposedValue;  
  
    public DisposeArray(uint initialLength = 0)  
    {  
        if (initialLength > 0) mArray = new T[initialLength];  
    }  
  
    public T this[int index]  
    {  
        get  
        {  
            ObjectDisposedException.ThrowIf(mDisposedValue, this);  
  
            if (mArray == null || index < 0 || index >= Count)  
            {  
                throw new IndexOutOfRangeException();  
            }  
  
            return mArray[index];  
        }  
        set  
        {  
            ObjectDisposedException.ThrowIf(mDisposedValue, this);  
  
            if (index < 0)  
            {  
                throw new IndexOutOfRangeException();  
            }  
  
            if (mArray == null)  
            {  
                mArray = new T[Math.Max(index + 1, 4)];  
            }  
            else if (index >= mArray.Length)  
            {  
                Array.Resize(ref mArray, Math.Max(index + 1, mArray.Length * 2));  
            }  
  
            if (mArray[index] is IDisposable disposable)  
            {  
                disposable.Dispose();  
            }  
  
            mArray[index] = value;  
            Count = Math.Max(Count, index + 1);  
        }  
    }  
  
    public int Count { get; private set; }  
  
    public int Capacity  
    {  
        get => mArray?.Length ?? 0;  
    }  
  
    public T[] ToArray()  
    {  
        ObjectDisposedException.ThrowIf(mDisposedValue, this);  
        return mArray == null || Count == 0 ? [] : mArray[..Count];  
    }  
  
    private void Dispose(bool disposing)  
    {  
        if (mDisposedValue) return;  
  
        if (disposing && mArray != null)  
        {  
            List<Exception> exceptions = [];  
  
            foreach (T item in mArray)  
            {  
                if (item is not IDisposable disposable)  
                {  
                    continue;  
                }  
  
                try  
                {  
                    disposable.Dispose();  
                }  
                catch (Exception ex)  
                {  
                    exceptions.Add(ex);  
                }  
            }  
  
            if (exceptions.Count > 0)  
            {  
                throw new AggregateException(exceptions);  
            }  
  
            mArray = null;  
        }  
  
        mDisposedValue = true;  
    }  
  
    ~DisposeArray() => Dispose(false);  
  
    public void Dispose()  
    {  
        Dispose(true);  
        GC.SuppressFinalize(this);  
    }  
}

Reference

c-sharpcorner.com, “Managed vs. Unmanaged Code in .NET”

C++에서 smart pointer를 사용하고, Rust 언어에서는 언어 수준 자체의 기능이다.

stackoverflow.com, “How free memory used by a large list in C#?, Answer:Oswaldo Junior”