🤔 데이터 파싱, 왜 이렇게 중요한 거야?

솔직히 말하면, 요즘 개발하면서 데이터 파싱을 안 쓰는 프로젝트는 거의 없다고 봐도 무방해.
API 호출하면 JSON이 날아오고, 레거시 시스템은 XML을 뱉어내고, 엑셀 데이터는 CSV로 넘어오고…
이 세 가지 포맷만 제대로 다룰 줄 알아도 개발 생산성이 눈에 띄게 달라진다는 거, 경험해본 사람은 다 알지! 😄

C#은 .NET 생태계 덕분에 JSON, XML, CSV 파싱을 위한 강력한 라이브러리들이 이미 잘 갖춰져 있어.
System.Text.Json, Newtonsoft.Json, System.Xml, LINQ to XML, CsvHelper 같은 도구들이 대표적이야.
이 글에서는 각 포맷별로 핵심 기법을 실전 코드와 함께 파헤쳐볼 거야. 준비됐지? 🔥

🔄 포맷 간 변환 — JSON ↔ XML ↔ CSV

실무에서는 한 포맷을 다른 포맷으로 변환해야 하는 경우가 정말 많아.
API에서 JSON으로 받은 데이터를 XML로 저장하거나, CSV 데이터를 JSON API로 전송하는 식이지.
이런 변환 작업을 깔끔하게 처리하는 방법을 알아보자! 🔄

🔹 JSON → XML 변환

using System.Xml.Linq;
using System.Text.Json;

// 방법 1: Newtonsoft.Json 활용 (가장 간편!)
// NuGet: Newtonsoft.Json
using Newtonsoft.Json;

string json = @"{
    ""직원목록"": {
        ""직원"": [
            {""이름"": ""홍길동"", ""나이"": 30},
            {""이름"": ""김철수"", ""나이"": 28}
        ]
    }
}";

// JSON → XmlDocument 변환 (Newtonsoft)
System.Xml.XmlDocument xmlDoc = JsonConvert.DeserializeXmlNode(json, "루트");
string xmlString = xmlDoc.OuterXml;
Console.WriteLine(xmlString);

// 방법 2: 수동 변환 (System.Text.Json + LINQ to XML)
using JsonDocument doc = JsonDocument.Parse(json);
XElement root = ConvertJsonToXml(doc.RootElement, "루트");

XElement ConvertJsonToXml(JsonElement element, string name)
{
    var xElement = new XElement(name);
    
    switch (element.ValueKind)
    {
        case JsonValueKind.Object:
            foreach (var prop in element.EnumerateObject())
                xElement.Add(ConvertJsonToXml(prop.Value, prop.Name));
            break;
        case JsonValueKind.Array:
            foreach (var item in element.EnumerateArray())
                xElement.Add(ConvertJsonToXml(item, "항목"));
            break;
        default:
            xElement.Value = element.ToString();
            break;
    }
    return xElement;
}

🔹 XML → JSON 변환

// Newtonsoft.Json으로 XML → JSON (초간단!)
using Newtonsoft.Json;

string xmlInput = @"
<직원목록>
    <직원>
        <이름>홍길동</이름>
        <나이>30</나이>
    </직원>
</직원목록>";

var xmlDoc = new System.Xml.XmlDocument();
xmlDoc.LoadXml(xmlInput);

string jsonResult = JsonConvert.SerializeXmlNode(xmlDoc, Formatting.Indented);
Console.WriteLine(jsonResult);

// 수동 변환 (LINQ to XML + System.Text.Json)
XDocument xDoc = XDocument.Parse(xmlInput);

var employees = xDoc.Root
    .Elements("직원")
    .Select(e => new
    {
        이름 = (string)e.Element("이름"),
        나이 = (int)e.Element("나이")
    })
    .ToList();

string json = JsonSerializer.Serialize(new { 직원목록 = employees }, 
    new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(json);

🔹 CSV → JSON 변환

using CsvHelper;
using System.Text.Json;
using System.Globalization;

// CSV 파일 → JSON 변환
public static string CsvToJson(string csvFilePath)
{
    using var reader = new StreamReader(csvFilePath, System.Text.Encoding.UTF8);
    using var csv = new CsvReader(reader, CultureInfo.InvariantCulture);
    
    // 동적으로 레코드 읽기
    var records = csv.GetRecords<dynamic>().ToList();
    
    return JsonSerializer.Serialize(records, new JsonSerializerOptions 
    { 
        WriteIndented = true 
    });
}

// 또는 Dictionary로 변환
public static string CsvToJsonManual(string csvContent)
{
    var lines = csvContent.Trim().Split('\n');
    var headers = lines[0].Split(',').Select(h => h.Trim()).ToArray();
    
    var records = new List<Dictionary<string, string>>();
    
    for (int i = 1; i < lines.Length; i++)
    {
        var values = lines[i].Split(',');
        var record = new Dictionary<string, string>();
        
        for (int j = 0; j < headers.Length && j < values.Length; j++)
        {
            record[headers[j]] = values[j].Trim();
        }
        records.Add(record);
    }
    
    return JsonSerializer.Serialize(records, new JsonSerializerOptions 
    { 
        WriteIndented = true,
        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
    });
}

🔹 JSON → CSV 변환

using System.Text.Json;
using CsvHelper;

// JSON 배열 → CSV 파일
public static void JsonToCsv<T>(string jsonString, string outputPath)
{
    var items = JsonSerializer.Deserialize<List<T>>(jsonString);
    
    using var writer = new StreamWriter(outputPath, false, System.Text.Encoding.UTF8);
    using var csv = new CsvWriter(writer, System.Globalization.CultureInfo.InvariantCulture);
    
    csv.WriteRecords(items);
}

// 사용 예시
string json = @"[
    {""이름"": ""홍길동"", ""나이"": 30, ""도시"": ""서울""},
    {""이름"": ""김철수"", ""나이"": 28, ""도시"": ""부산""}
]";

JsonToCsv<Person>(json, "output.csv");
Console.WriteLine("JSON → CSV 변환 완료!");

⚡ 고급 기법 — 실무에서 바로 쓰는 테크닉

🔹 비동기 처리 (Async/Await)

파일 I/O나 HTTP 요청에서 데이터를 파싱할 때는 비동기 처리가 필수야.
특히 대용량 데이터를 다룰 때 UI 스레드를 블로킹하지 않으려면 꼭 알아야 해!

using System.Net.Http;
using System.Text.Json;

// HTTP API에서 JSON 비동기 파싱
public class ApiService
{
    private readonly HttpClient _httpClient;
    
    public ApiService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }
    
    public async Task<List<User>> GetUsersAsync(string apiUrl)
    {
        // HTTP GET 요청
        HttpResponseMessage response = await _httpClient.GetAsync(apiUrl);
        response.EnsureSuccessStatusCode();
        
        // 스트림으로 직접 역직렬화 (메모리 효율적!)
        await using Stream stream = await response.Content.ReadAsStreamAsync();
        
        var options = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true // 대소문자 무시
        };
        
        return await JsonSerializer.DeserializeAsync<List<User>>(stream, options)
               ?? new List<User>();
    }
    
    // 비동기 파일 읽기 + JSON 파싱
    public async Task<T?> ReadJsonFileAsync<T>(string filePath)
    {
        await using FileStream fs = File.OpenRead(filePath);
        return await JsonSerializer.DeserializeAsync<T>(fs);
    }
}

🔹 Source Generator 활용 (AOT 최적화)

.NET 6+에서는 JsonSerializerContext를 사용한 소스 제너레이터 방식으로
리플렉션 없이 JSON 직렬화를 처리할 수 있어. AOT(Ahead-of-Time) 컴파일 환경에서 필수야!

using System.Text.Json.Serialization;

// JsonSerializerContext 정의
[JsonSerializable(typeof(User))]
[JsonSerializable(typeof(List<User>))]
[JsonSerializable(typeof(Product))]
public partial class AppJsonContext : JsonSerializerContext { }

// 사용 예시 (리플렉션 없이 빠른 직렬화!)
var user = new User { Id = 1, Name = "홍길동" };

// Source Generator 방식
string json = JsonSerializer.Serialize(user, AppJsonContext.Default.User);
User? parsed = JsonSerializer.Deserialize(json, AppJsonContext.Default.User);

Console.WriteLine($"이름: {parsed?.Name}");

🔹 대용량 데이터 스트리밍 처리

using System.Text.Json;

// Utf8JsonWriter로 대용량 JSON 스트리밍 생성
public async Task WriteHugeJsonAsync(IEnumerable<User> users, Stream outputStream)
{
    await using var writer = new Utf8JsonWriter(outputStream, 
        new JsonWriterOptions { Indented = false });
    
    writer.WriteStartArray();
    
    foreach (var user in users)
    {
        writer.WriteStartObject();
        writer.WriteNumber("id", user.Id);
        writer.WriteString("name", user.Name);
        writer.WriteString("email", user.Email);
        writer.WriteBoolean("isActive", user.IsActive);
        writer.WriteEndObject();
        
        // 주기적으로 플러시 (메모리 관리)
        if (writer.BytesPending > 65536) // 64KB마다
        {
            await writer.FlushAsync();
        }
    }
    
    writer.WriteEndArray();
    await writer.FlushAsync();
}

🔹 에러 처리 패턴

// 안전한 JSON 파싱 패턴
public static T? SafeDeserialize<T>(string json, ILogger? logger = null)
{
    try
    {
        if (string.IsNullOrWhiteSpace(json))
        {
            logger?.LogWarning("빈 JSON 문자열이 입력되었습니다.");
            return default;
        }
        
        return JsonSerializer.Deserialize<T>(json, new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true,
            AllowTrailingCommas = true,  // 후행 쉼표 허용
            ReadCommentHandling = JsonCommentHandling.Skip  // 주석 무시
        });
    }
    catch (JsonException ex)
    {
        logger?.LogError(ex, "JSON 파싱 실패: {Path}", ex.Path);
        return default;
    }
}

// Result 패턴으로 에러 처리
public record ParseResult<T>(bool Success, T? Data, string? ErrorMessage);

public static ParseResult<T> TryParseJson<T>(string json)
{
    try
    {
        var data = JsonSerializer.Deserialize<T>(json);
        return new ParseResult<T>(true, data, null);
    }
    catch (JsonException ex)
    {
        return new ParseResult<T>(false, default, ex.Message);
    }
}

// 사용
var result = TryParseJson<User>(someJson);
if (result.Success)
    Console.WriteLine($"파싱 성공: {result.Data?.Name}");
else
    Console.WriteLine($"파싱 실패: {result.ErrorMessage}");

🏎️ 성능 비교 — 어떤 방법이 가장 빠를까?

같은 작업이라도 어떤 방법을 쓰느냐에 따라 성능 차이가 크게 날 수 있어.
BenchmarkDotNet 기반 실제 벤치마크 결과를 참고해서 상황에 맞는 선택을 하자!

// ✅ 좋은 예: JsonSerializerOptions를 static으로 재사용
public static class JsonHelper
{
    private static readonly JsonSerializerOptions _options = new()
    {
        PropertyNameCaseInsensitive = true,
        WriteIndented = false,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
    };
    
    public static T? Deserialize<T>(string json) 
        => JsonSerializer.Deserialize<T>(json, _options);
    
    public static string Serialize<T>(T obj) 
        => JsonSerializer.Serialize(obj, _options);
}

// ❌ 나쁜 예: 매번 새 옵션 객체 생성 (성능 저하!)
public static T? BadDeserialize<T>(string json)
    => JsonSerializer.Deserialize<T>(json, new JsonSerializerOptions 
    { 
        PropertyNameCaseInsensitive = true  // 매번 새로 생성 = 느림!
    });

🛠️ 실전 예제 — 종합 데이터 처리 파이프라인

지금까지 배운 내용을 종합해서 실제 업무에서 쓸 수 있는 데이터 처리 파이프라인을 만들어보자!
CSV 파일을 읽어서 처리하고, JSON API로 전송하고, 결과를 XML로 저장하는 시나리오야. 🎯

using System.Text.Json;
using System.Xml.Linq;
using CsvHelper;
using System.Globalization;
using System.Net.Http;

// 데이터 모델
public record Employee(
    int Id,
    string Name,
    string Department,
    decimal Salary,
    DateTime HireDate
);

public class DataPipeline
{
    private readonly HttpClient _httpClient;
    
    public DataPipeline(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }
    
    // Step 1: CSV 읽기
    public async Task<List<Employee>> ReadFromCsvAsync(string filePath)
    {
        using var reader = new StreamReader(filePath, System.Text.Encoding.UTF8);
        using var csv = new CsvReader(reader, CultureInfo.InvariantCulture);
        
        return await Task.Run(() => csv.GetRecords<Employee>().ToList());
    }
    
    // Step 2: 데이터 처리 (예: 급여 10% 인상)
    public List<Employee> ProcessData(List<Employee> employees)
    {
        return employees
            .Where(e => e.Salary > 0)  // 유효한 데이터만
            .Select(e => e with { Salary = e.Salary * 1.1m })  // 10% 인상
            .OrderBy(e => e.Department)
            .ThenBy(e => e.Name)
            .ToList();
    }
    
    // Step 3: JSON API로 전송
    public async Task<bool> SendToApiAsync(List<Employee> employees, string apiUrl)
    {
        var json = JsonSerializer.Serialize(employees, new JsonSerializerOptions
        {
            WriteIndented = false,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        });
        
        var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
        
        try
        {
            var response = await _httpClient.PostAsync(apiUrl, content);
            return response.IsSuccessStatusCode;
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"API 전송 실패: {ex.Message}");
            return false;
        }
    }
    
    // Step 4: XML로 결과 저장
    public async Task SaveToXmlAsync(List<Employee> employees, string outputPath)
    {
        var xDoc = new XDocument(
            new XDeclaration("1.0", "utf-8", "yes"),
            new XElement("직원목록",
                new XAttribute("생성일시", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
                new XAttribute("총인원", employees.Count),
                employees.Select(e => new XElement("직원",
                    new XAttribute("id", e.Id),
                    new XElement("이름", e.Name),
                    new XElement("부서", e.Department),
                    new XElement("급여", e.Salary.ToString("N0")),
                    new XElement("입사일", e.HireDate.ToString("yyyy-MM-dd"))
                ))
            )
        );
        
        await Task.Run(() => xDoc.Save(outputPath));
        Console.WriteLine($"XML 저장 완료: {outputPath}");
    }
    
    // 전체 파이프라인 실행
    public async Task RunPipelineAsync(string csvPath, string apiUrl, string xmlOutput)
    {
        Console.WriteLine("🚀 데이터 파이프라인 시작...");
        
        // 1. CSV 읽기
        var rawData = await ReadFromCsvAsync(csvPath);
        Console.WriteLine($"✅ CSV 읽기 완료: {rawData.Count}건");
        
        // 2. 처리
        var processed = ProcessData(rawData);
        Console.WriteLine($"✅ 데이터 처리 완료: {processed.Count}건");
        
        // 3. API 전송
        bool apiSuccess = await SendToApiAsync(processed, apiUrl);
        Console.WriteLine($"✅ API 전송: {(apiSuccess ? "성공" : "실패")}");
        
        // 4. XML 저장
        await SaveToXmlAsync(processed, xmlOutput);
        Console.WriteLine("🎉 파이프라인 완료!");
    }
}

// 실행
var pipeline = new DataPipeline(new HttpClient());
await pipeline.RunPipelineAsync(
    csvPath: "employees.csv",
    apiUrl: "https://api.example.com/employees",
    xmlOutput: "result.xml"
);

💡 마무리 — 실무에서 꼭 기억할 것들

여기까지 JSON, XML, CSV 파싱과 변환의 핵심을 모두 살펴봤어!
마지막으로 실무에서 꼭 기억해야 할 베스트 프랙티스들을 정리해줄게. 📝

데이터 파싱 실력은 C# 개발자로서의 기본기 중에서도 핵심이야.
이 글에서 다룬 기법들을 실제 프로젝트에 적용해보면서 손에 익히는 게 가장 중요해!

혹시 C# 데이터 처리 관련 프로젝트를 진행하다가 막히는 부분이 있다면,
재능넷에서 C# 전문 개발자의 도움을 받아보는 것도 좋은 방법이야.
다양한 실력자들이 데이터 파싱부터 아키텍처 설계까지 도움을 줄 수 있거든! 😊