1. JSON 기초 개념 🧠

일단 JSON이 뭔지부터 간단히 짚고 넘어갈게요! JSON(JavaScript Object Notation)은 데이터 교환 포맷으로, 사람이 읽기 쉽고 기계가 파싱하기도 쉬운 텍스트 기반 데이터 형식이에요.

JSON의 기본 구조는 이렇게 생겼어요:

{
  "name": "홍길동",
  "age": 30,
  "isStudent": false,
  "hobbies": ["코딩", "게임", "독서"],
  "address": {
    "city": "서울",
    "zipcode": "12345"
  }
}

진짜 단순하고 직관적이죠? ㅋㅋㅋ 이런 구조 때문에 거의 모든 프로그래밍 언어에서 지원하고 있어요. C#에서도 당연히 JSON을 다루는 라이브러리가 여러 개 있는데, 그중에서도 가장 많이 사용되는 두 가지를 비교해볼게요! 🔍

C#에서 JSON을 다루는 방법은 크게 두 가지예요:

1. Newtonsoft.Json(Json.NET): 오랫동안 사실상 표준(de facto standard)으로 사용되어 온 서드파티 라이브러리
2. System.Text.Json: .NET Core 3.0부터 도입된 마이크로소프트의 공식 JSON 라이브러리

이제 각각의 라이브러리에 대해 자세히 알아보도록 할게요! 😊

2. Newtonsoft.Json(Json.NET) 소개 🏆

Newtonsoft.Json(일명 Json.NET)은 James Newton-King이 개발한 라이브러리로, 오랫동안 C# 개발자들의 사랑을 받아왔어요. 진짜 레전드급이라 할 수 있죠! ㅋㅋㅋ

2.1 주요 특징

1. 풍부한 기능: Json.NET은 정말 다양한 기능을 제공해요. 복잡한 객체 그래프도 쉽게 직렬화/역직렬화할 수 있고, LINQ to JSON도 지원해요.

2. 높은 유연성: 커스텀 컨버터, 다양한 설정 옵션 등을 통해 거의 모든 시나리오에 대응할 수 있어요.

3. 안정성: 오랜 기간 사용되면서 많은 버그가 수정되고 안정화되었어요.

4. 풍부한 문서와 커뮤니티: 사용 방법에 대한 문서와 예제가 풍부하고, 문제 발생 시 검색하면 해결책을 쉽게 찾을 수 있어요.

2.2 기본 사용법

NuGet 패키지 매니저를 통해 설치할 수 있어요:

Install-Package Newtonsoft.Json

또는

dotnet add package Newtonsoft.Json

기본적인 직렬화/역직렬화 예제를 살펴볼게요:

using Newtonsoft.Json;

// 클래스 정의
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Hobbies { get; set; }
}

// 객체 생성
var person = new Person
{
    Name = "홍길동",
    Age = 30,
    Hobbies = new List<string> { "코딩", "게임", "독서" }
};

// 직렬화 (객체 → JSON 문자열)
string json = JsonConvert.SerializeObject(person);
Console.WriteLine(json);
// 출력: {"Name":"홍길동","Age":30,"Hobbies":["코딩","게임","독서"]}

// 역직렬화 (JSON 문자열 → 객체)
Person deserializedPerson = JsonConvert.DeserializeObject<Person>(json);
Console.WriteLine(deserializedPerson.Name); // 출력: 홍길동

진짜 간단하죠? ㅋㅋㅋ 이렇게 JsonConvert 클래스의 정적 메서드를 사용하면 끝이에요! 👍

2.3 고급 기능

Json.NET의 강점은 다양한 고급 기능을 제공한다는 점이에요. 몇 가지 예를 살펴볼게요:

2.3.1 JSON 속성 커스터마이징

public class Person
{
    [JsonProperty("full_name")] // JSON에서는 "full_name"으로 표시됨
    public string Name { get; set; }
    
    [JsonProperty("years_old")]
    public int Age { get; set; }
    
    [JsonIgnore] // 이 속성은 JSON에 포함되지 않음
    public string SecretData { get; set; }
}

2.3.2 LINQ to JSON

// JSON 파싱 및 조작
JObject jObject = JObject.Parse(@"{
  'name': '홍길동',
  'age': 30,
  'hobbies': ['코딩', '게임', '독서']
}");

// 값 접근 및 수정
string name = (string)jObject["name"];
jObject["age"] = 31;

// 새 속성 추가
jObject.Add("isStudent", false);

// 다시 문자열로 변환
string modifiedJson = jObject.ToString();

2.3.3 커스텀 컨버터

public class DateTimeConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(DateTime);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        string dateString = (string)reader.Value;
        return DateTime.ParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        DateTime date = (DateTime)value;
        writer.WriteValue(date.ToString("yyyy-MM-dd"));
    }
}

// 사용 방법
JsonSerializerSettings settings = new JsonSerializerSettings
{
    Converters = new List<JsonConverter> { new DateTimeConverter() }
};

string json = JsonConvert.SerializeObject(myObject, settings);

이런 고급 기능들 덕분에 Json.NET은 복잡한 JSON 처리 요구사항도 쉽게 해결할 수 있어요. 진짜 만능 칼이라고 할 수 있죠! 🔪✨

3. System.Text.Json 소개 🆕

System.Text.Json은 .NET Core 3.0부터 도입된 마이크로소프트의 공식 JSON 라이브러리예요. 마이크로소프트가 "우리도 JSON 라이브러리 만들어볼게요~" 하고 내놓은 거죠! ㅋㅋㅋ

3.1 주요 특징

1. 높은 성능: System.Text.Json은 성능에 초점을 맞춰 설계되었어요. Newtonsoft.Json보다 더 빠르고 메모리 사용량도 적어요.

2. 내장 라이브러리: .NET Core 3.0 이상에서는 별도의 패키지 설치 없이 바로 사용할 수 있어요.

3. 비동기 지원: 처음부터 비동기 API를 고려하여 설계되었어요.

4. UTF-8 지원: UTF-8 인코딩을 직접 지원하여 문자열 변환 오버헤드를 줄였어요.

3.2 기본 사용법

.NET Core 3.0 이상에서는 별도의 패키지 설치 없이 사용할 수 있어요. .NET Framework나 이전 버전의 .NET Core에서는 NuGet 패키지를 설치해야 해요:

Install-Package System.Text.Json

또는

dotnet add package System.Text.Json

기본적인 직렬화/역직렬화 예제를 살펴볼게요:

using System.Text.Json;

// 클래스 정의
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Hobbies { get; set; }
}

// 객체 생성
var person = new Person
{
    Name = "홍길동",
    Age = 30,
    Hobbies = new List<string> { "코딩", "게임", "독서" }
};

// 직렬화 (객체 → JSON 문자열)
string json = JsonSerializer.Serialize(person);
Console.WriteLine(json);
// 출력: {"Name":"홍길동","Age":30,"Hobbies":["코딩","게임","독서"]}

// 역직렬화 (JSON 문자열 → 객체)
Person deserializedPerson = JsonSerializer.Deserialize<Person>(json);
Console.WriteLine(deserializedPerson.Name); // 출력: 홍길동

Json.NET과 비슷하게 JsonSerializer 클래스의 정적 메서드를 사용해요. 근데 이름이 좀 다르죠? ㅋㅋㅋ

3.3 고급 기능

System.Text.Json도 다양한 고급 기능을 제공하지만, Json.NET보다는 제한적이에요. 몇 가지 예를 살펴볼게요:

3.3.1 JSON 속성 커스터마이징

public class Person
{
    [JsonPropertyName("full_name")] // JSON에서는 "full_name"으로 표시됨
    public string Name { get; set; }
    
    [JsonPropertyName("years_old")]
    public int Age { get; set; }
    
    [JsonIgnore] // 이 속성은 JSON에 포함되지 않음
    public string SecretData { get; set; }
}

3.3.2 직렬화 옵션 설정

var options = new JsonSerializerOptions
{
    WriteIndented = true, // 들여쓰기 적용
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase, // 속성 이름을 camelCase로 변환
    IgnoreNullValues = true // null 값 무시
};

string json = JsonSerializer.Serialize(person, options);

3.3.3 커스텀 컨버터

public class DateTimeConverter : JsonConverter<DateTime>
{
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        string dateString = reader.GetString();
        return DateTime.ParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture);
    }

    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value.ToString("yyyy-MM-dd"));
    }
}

// 사용 방법
var options = new JsonSerializerOptions
{
    Converters = { new DateTimeConverter() }
};

string json = JsonSerializer.Serialize(myObject, options);

System.Text.Json은 Json.NET보다 API가 좀 더 현대적이고 타입 안전성이 높아요. 하지만 아직 Json.NET만큼 다양한 기능을 제공하지는 않아요. 그래도 기본적인 JSON 처리는 충분히 가능하고, 성능이 중요한 경우에는 좋은 선택이 될 수 있어요! 🚀

4. 두 라이브러리 성능 비교 🏎️

이제 진짜 중요한 부분이죠! 성능 비교! 어떤 라이브러리가 더 빠를까요? 🤔

마이크로소프트에서 공개한 벤치마크 결과와 여러 개발자들의 테스트 결과를 종합해보면, System.Text.Json이 Newtonsoft.Json보다 전반적으로 더 빠르고 메모리 사용량도 적어요. 특히 대용량 JSON 데이터를 처리할 때 그 차이가 더 두드러져요.

4.1 직렬화 성능

대략적인 벤치마크 결과를 보면:

// 10,000개의 객체를 포함하는 배열 직렬화 벤치마크 결과
System.Text.Json: 약 45ms
Newtonsoft.Json: 약 120ms

거의 3배 가까이 차이가 나네요! 😲

4.2 역직렬화 성능

// 10,000개의 객체를 포함하는 JSON 문자열 역직렬화 벤치마크 결과
System.Text.Json: 약 60ms
Newtonsoft.Json: 약 150ms

역직렬화도 System.Text.Json이 훨씬 빠르네요! 🚀

4.3 메모리 사용량

메모리 사용량도 System.Text.Json이 더 적어요. 특히 대용량 JSON을 처리할 때 그 차이가 더 커져요.

// 10,000개의 객체를 직렬화할 때 메모리 사용량
System.Text.Json: 약 15MB
Newtonsoft.Json: 약 40MB

이런 성능 차이가 나는 이유는 뭘까요? 🧐

1. System.Text.Json은 처음부터 성능을 고려하여 설계되었어요.
2. UTF-8 인코딩을 직접 지원하여 문자열 변환 오버헤드를 줄였어요.
3. 최신 .NET 기능(Span<T>, Memory<T> 등)을 활용하여 메모리 할당을 최소화했어요.
4. Json.NET은 더 많은 기능과 유연성을 제공하기 위해 내부적으로 더 복잡한 구조를 가지고 있어요.

하지만! 성능만이 전부는 아니에요. 실제 프로젝트에서는 기능, 유연성, 사용 편의성 등 다양한 요소를 고려해야 해요. 그리고 대부분의 소규모 애플리케이션에서는 이 정도 성능 차이가 체감되지 않을 수도 있어요. 진짜 대용량 데이터를 다루는 고성능 애플리케이션이 아니라면요! ㅋㅋㅋ

5. 직렬화(Serialization) 비교 📦

이제 두 라이브러리의 직렬화 기능을 좀 더 자세히 비교해볼게요! 🔍

5.1 기본 직렬화 동작

두 라이브러리의 기본 직렬화 동작에는 몇 가지 차이가 있어요:

// 예시 클래스
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public DateTime BirthDate { get; set; }
    public List<string> Hobbies { get; set; }
    public Dictionary<string, object> AdditionalData { get; set; }
}

5.1.1 Newtonsoft.Json

var person = new Person
{
    Name = "홍길동",
    Age = 30,
    BirthDate = new DateTime(1993, 1, 15),
    Hobbies = new List<string> { "코딩", "게임", "독서" },
    AdditionalData = new Dictionary<string, object>
    {
        { "IsStudent", false },
        { "GPA", 3.8 }
    }
};

// 기본 직렬화
string json = JsonConvert.SerializeObject(person);
// 결과: {"Name":"홍길동","Age":30,"BirthDate":"1993-01-15T00:00:00","Hobbies":["코딩","게임","독서"],"AdditionalData":{"IsStudent":false,"GPA":3.8}}

// 들여쓰기 적용
string prettyJson = JsonConvert.SerializeObject(person, Formatting.Indented);
// 결과: 들여쓰기가 적용된 JSON

5.1.2 System.Text.Json

var person = new Person
{
    Name = "홍길동",
    Age = 30,
    BirthDate = new DateTime(1993, 1, 15),
    Hobbies = new List<string> { "코딩", "게임", "독서" },
    AdditionalData = new Dictionary<string, object>
    {
        { "IsStudent", false },
        { "GPA", 3.8 }
    }
};

// 기본 직렬화
string json = JsonSerializer.Serialize(person);
// 결과: {"Name":"홍길동","Age":30,"BirthDate":"1993-01-15T00:00:00","Hobbies":["코딩","게임","독서"],"AdditionalData":{"IsStudent":false,"GPA":3.8}}

// 들여쓰기 적용
var options = new JsonSerializerOptions { WriteIndented = true };
string prettyJson = JsonSerializer.Serialize(person, options);
// 결과: 들여쓰기가 적용된 JSON

기본적인 직렬화 결과는 비슷하지만, System.Text.Json은 옵션을 설정하는 방식이 다르고, 일부 고급 시나리오에서는 차이가 있을 수 있어요.

5.2 속성 이름 처리

5.2.1 Newtonsoft.Json

// camelCase로 속성 이름 변환
var settings = new JsonSerializerSettings
{
    ContractResolver = new CamelCasePropertyNamesContractResolver()
};
string json = JsonConvert.SerializeObject(person, settings);
// 결과: {"name":"홍길동","age":30,...}

5.2.2 System.Text.Json

// camelCase로 속성 이름 변환
var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
string json = JsonSerializer.Serialize(person, options);
// 결과: {"name":"홍길동","age":30,...}

5.3 날짜/시간 형식

5.3.1 Newtonsoft.Json

// ISO 8601 형식 사용 (기본값)
string json1 = JsonConvert.SerializeObject(person);
// 결과: {"BirthDate":"1993-01-15T00:00:00"}

// 커스텀 날짜 형식 지정
var settings = new JsonSerializerSettings
{
    DateFormatString = "yyyy-MM-dd"
};
string json2 = JsonConvert.SerializeObject(person, settings);
// 결과: {"BirthDate":"1993-01-15"}

5.3.2 System.Text.Json

// ISO 8601 형식 사용 (기본값)
string json1 = JsonSerializer.Serialize(person);
// 결과: {"BirthDate":"1993-01-15T00:00:00"}

// 커스텀 날짜 형식은 직접 지원하지 않음
// 커스텀 컨버터를 구현해야 함
public class DateTimeConverter : JsonConverter<DateTime>
{
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        return DateTime.Parse(reader.GetString());
    }

    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value.ToString("yyyy-MM-dd"));
    }
}

var options = new JsonSerializerOptions
{
    Converters = { new DateTimeConverter() }
};
string json2 = JsonSerializer.Serialize(person, options);
// 결과: {"BirthDate":"1993-01-15"}

System.Text.Json은 날짜 형식을 직접 지정하는 옵션이 없어서 커스텀 컨버터를 구현해야 해요. 좀 귀찮죠? ㅋㅋㅋ

5.4 순환 참조 처리

5.4.1 Newtonsoft.Json

public class Employee
{
    public string Name { get; set; }
    public Employee Manager { get; set; }
    public List<Employee> Subordinates { get; set; }
}

var ceo = new Employee { Name = "CEO" };
var manager = new Employee { Name = "Manager", Manager = ceo };
ceo.Subordinates = new List<Employee> { manager };
// 순환 참조 발생!

// ReferenceLoopHandling 옵션으로 해결
var settings = new JsonSerializerSettings
{
    ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
string json = JsonConvert.SerializeObject(ceo, settings);
// 순환 참조를 무시하고 직렬화됨

5.4.2 System.Text.Json

// System.Text.Json은 기본적으로 순환 참조를 감지하면 예외를 발생시킴
// .NET 6.0부터 ReferenceHandler.Preserve 옵션 제공
var options = new JsonSerializerOptions
{
    ReferenceHandler = ReferenceHandler.Preserve
};
string json = JsonSerializer.Serialize(ceo, options);
// $id와 $ref를 사용하여 참조 처리

.NET 5.0 이하에서는 System.Text.Json으로 순환 참조를 처리하기가 어려워요. 이건 진짜 큰 단점 중 하나죠! 😅

직렬화 측면에서는 Newtonsoft.Json이 더 많은 옵션과 유연성을 제공하는 반면, System.Text.Json은 더 간결하고 성능이 좋아요. 프로젝트의 요구사항에 따라 적절한 라이브러리를 선택하는 게 중요해요! 🎯

6. 역직렬화(Deserialization) 비교 📥

이번에는 두 라이브러리의 역직렬화 기능을 비교해볼게요! JSON 문자열을 객체로 변환하는 과정이죠. 😊

6.1 기본 역직렬화 동작

6.1.1 Newtonsoft.Json

string json = @"{
  ""Name"": ""홍길동"",
  ""Age"": 30,
  ""BirthDate"": ""1993-01-15T00:00:00"",
  ""Hobbies"": [""코딩"", ""게임"", ""독서""],
  ""AdditionalData"": {
    ""IsStudent"": false,
    ""GPA"": 3.8
  }
}";

// 기본 역직렬화
Person person = JsonConvert.DeserializeObject<Person>(json);

// 익명 타입으로 역직렬화
var anonymous = JsonConvert.DeserializeObject(json);
// dynamic 타입으로 사용 가능
string name = anonymous.Name;

6.1.2 System.Text.Json

string json = @"{
  ""Name"": ""홍길동"",
  ""Age"": 30,
  ""BirthDate"": ""1993-01-15T00:00:00"",
  ""Hobbies"": [""코딩"", ""게임"", ""독서""],
  ""AdditionalData"": {
    ""IsStudent"": false,
    ""GPA"": 3.8
  }
}";

// 기본 역직렬화
Person person = JsonSerializer.Deserialize<Person>(json);

// JsonDocument로 역직렬화
using JsonDocument doc = JsonDocument.Parse(json);
string name = doc.RootElement.GetProperty("Name").GetString();
int age = doc.RootElement.GetProperty("Age").GetInt32();

System.Text.Json은 dynamic 타입을 직접 지원하지 않아요. 대신 JsonDocument를 사용해서 JSON 문서를 탐색할 수 있어요. 근데 좀 더 코드가 길어지고 복잡해지는 단점이 있죠. ㅠㅠ

6.2 대소문자 구분

6.2.1 Newtonsoft.Json

// 기본적으로 대소문자를 구분하지 않음
string json = @"{""name"": ""홍길동"", ""age"": 30}"; // 소문자로 된 속성 이름
Person person = JsonConvert.DeserializeObject<Person>(json);
// person.Name은 "홍길동"으로 설정됨

// 대소문자 구분 설정
var settings = new JsonSerializerSettings
{
    ContractResolver = new DefaultContractResolver { NamingStrategy = new DefaultNamingStrategy() }
};
Person person2 = JsonConvert.DeserializeObject<Person>(json, settings);
// 대소문자를 구분하면 person2.Name은 null이 됨

6.2.2 System.Text.Json

// 기본적으로 대소문자를 구분함
string json = @"{""name"": ""홍길동"", ""age"": 30}"; // 소문자로 된 속성 이름
Person person = JsonSerializer.Deserialize<Person>(json);
// person.Name은 null이 됨 (대소문자가 다르기 때문)

// 대소문자 구분 비활성화
var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true
};
Person person2 = JsonSerializer.Deserialize<Person>(json, options);
// person2.Name은 "홍길동"으로 설정됨

이 부분은 진짜 중요한 차이점이에요! Newtonsoft.Json은 기본적으로 대소문자를 구분하지 않지만, System.Text.Json은 기본적으로 대소문자를 구분해요. 이 차이 때문에 라이브러리를 전환할 때 문제가 생길 수 있어요! 😱

6.3 누락된 속성 처리

6.3.1 Newtonsoft.Json

// JSON에 없는 속성은 기본값으로 설정됨
string json = @"{""Name"": ""홍길동""}"; // Age 속성이 없음
Person person = JsonConvert.DeserializeObject<Person>(json);
// person.Age는 0(int의 기본값)으로 설정됨

// MissingMemberHandling 옵션으로 동작 변경
var settings = new JsonSerializerSettings
{
    MissingMemberHandling = MissingMemberHandling.Error
};
// 아래 코드는 예외 발생
// Person person2 = JsonConvert.DeserializeObject<Person>(json, settings);

6.3.2 System.Text.Json

// JSON에 없는 속성은 기본값으로 설정됨
string json = @"{""Name"": ""홍길동""}"; // Age 속성이 없음
Person person = JsonSerializer.Deserialize<Person>(json);
// person.Age는 0(int의 기본값)으로 설정됨

// System.Text.Json은 누락된 속성에 대한 오류 옵션이 없음

System.Text.Json은 누락된 속성에 대해 오류를 발생시키는 옵션이 없어요. 이런 세밀한 제어가 필요하다면 Newtonsoft.Json이 더 적합할 수 있어요.

6.4 알 수 없는 속성 처리

6.4.1 Newtonsoft.Json

// JSON에 클래스에 없는 속성이 있는 경우
string json = @"{""Name"": ""홍길동"", ""Age"": 30, ""Unknown"": ""value""}";
Person person = JsonConvert.DeserializeObject<Person>(json);
// "Unknown" 속성은 무시됨

// 알 수 없는 속성에 대해 오류 발생
var settings = new JsonSerializerSettings
{
    MissingMemberHandling = MissingMemberHandling.Ignore,
    MetadataPropertyHandling = MetadataPropertyHandling.Ignore
};
// 아래 코드는 예외 발생
// Person person2 = JsonConvert.DeserializeObject<Person>(json, settings);

6.4.2 System.Text.Json

// JSON에 클래스에 없는 속성이 있는 경우
string json = @"{""Name"": ""홍길동"", ""Age"": 30, ""Unknown"": ""value""}";
Person person = JsonSerializer.Deserialize<Person>(json);
// "Unknown" 속성은 무시됨

// 알 수 없는 속성에 대해 오류 발생
var options = new JsonSerializerOptions
{
    UnknownTypeHandling = JsonUnknownTypeHandling.JsonNode,
    MaxDepth = 64
};
// 아래 코드는 예외 발생
// Person person2 = JsonSerializer.Deserialize<Person>(json, options);

두 라이브러리 모두 기본적으로 알 수 없는 속성을 무시하지만, 오류를 발생시키는 옵션도 제공해요.

6.5 다형성(Polymorphism) 지원

6.5.1 Newtonsoft.Json

public class Animal
{
    public string Name { get; set; }
    public string Type { get; set; }
}

public class Dog : Animal
{
    public string Breed { get; set; }
}

public class Cat : Animal
{
    public bool IsIndoor { get; set; }
}

// TypeNameHandling 옵션으로 다형성 지원
var settings = new JsonSerializerSettings
{
    TypeNameHandling = TypeNameHandling.Auto
};

var dog = new Dog { Name = "바둑이", Type = "Dog", Breed = "진돗개" };
string json = JsonConvert.SerializeObject(dog, settings);
// 결과: {"$type":"MyNamespace.Dog, MyAssembly","Name":"바둑이","Type":"Dog","Breed":"진돗개"}

Animal animal = JsonConvert.DeserializeObject<Animal>(json, settings);
// animal은 실제로 Dog 타입

6.5.2 System.Text.Json

// System.Text.Json은 .NET 6.0 이전에는 다형성을 직접 지원하지 않음
// .NET 6.0부터 JsonPolymorphicTypeResolver 제공

// .NET 6.0 이전에는 커스텀 컨버터를 구현해야 함
public class AnimalConverter : JsonConverter<Animal>
{
    public override Animal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        using var doc = JsonDocument.Parse(reader.GetRawValue());
        var root = doc.RootElement;
        
        if (root.TryGetProperty("Type", out var typeProperty))
        {
            string type = typeProperty.GetString();
            if (type == "Dog")
            {
                return JsonSerializer.Deserialize<Dog>(root.GetRawText(), options);
            }
            else if (type == "Cat")
            {
                return JsonSerializer.Deserialize<Cat>(root.GetRawText(), options);
            }
        }
        
        return JsonSerializer.Deserialize<Animal>(root.GetRawText(), options);
    }

    public override void Write(Utf8JsonWriter writer, Animal value, JsonSerializerOptions options)
    {
        JsonSerializer.Serialize(writer, value, value.GetType(), options);
    }
}

다형성 지원은 Newtonsoft.Json이 훨씬 간편하고 강력해요. System.Text.Json은 .NET 6.0부터 개선되었지만, 여전히 더 복잡한 구현이 필요해요.

역직렬화 측면에서도 Newtonsoft.Json이 더 많은 기능과 옵션을 제공하는 반면, System.Text.Json은 성능에 초점을 맞추고 있어요. 복잡한 역직렬화 시나리오가 많다면 Newtonsoft.Json이 더 적합할 수 있어요! 🧩

7. 고급 기능 비교 🔧

이제 두 라이브러리의 고급 기능들을 비교해볼게요! 여기서 진짜 차이가 많이 나타나거든요! 🧐

7.1 LINQ to JSON

7.1.1 Newtonsoft.Json

Newtonsoft.Json은 LINQ to JSON이라는 강력한 기능을 제공해요. 이를 통해 JSON 데이터를 쉽게 쿼리하고 조작할 수 있어요.

string json = @"{
  ""name"": ""홍길동"",
  ""age"": 30,
  ""address"": {
    ""city"": ""서울"",
    ""zipcode"": ""12345""
  },
  ""hobbies"": [""코딩"", ""게임"", ""독서""]
}";

// JObject로 파싱
JObject jObject = JObject.Parse(json);

// 값 접근
string name = (string)jObject["name"];
int age = (int)jObject["age"];
string city = (string)jObject["address"]["city"];
string firstHobby = (string)jObject["hobbies"][0];

// 값 수정
jObject["age"] = 31;
jObject["address"]["city"] = "부산";

// 새 속성 추가
jObject["isStudent"] = false;
jObject["scores"] = new JArray(90, 85, 95);

// 속성 삭제
jObject.Remove("hobbies");

// LINQ 쿼리 사용
var query = from hobby in jObject["hobbies"]
            where hobby.ToString().Length > 2
            select hobby;

// 다시 JSON 문자열로 변환
string modifiedJson = jObject.ToString();

7.1.2 System.Text.Json

System.Text.Json은 LINQ to JSON과 같은 기능을 직접 제공하지 않아요. 대신 JsonDocument와 JsonElement를 사용하여 JSON 데이터를 탐색할 수 있어요.

string json = @"{
  ""name"": ""홍길동"",
  ""age"": 30,
  ""address"": {
    ""city"": ""서울"",
    ""zipcode"": ""12345""
  },
  ""hobbies"": [""코딩"", ""게임"", ""독서""]
}";

// JsonDocument로 파싱
using JsonDocument doc = JsonDocument.Parse(json);
JsonElement root = doc.RootElement;

// 값 접근
string name = root.GetProperty("name").GetString();
int age = root.GetProperty("age").GetInt32();
string city = root.GetProperty("address").GetProperty("city").GetString();
string firstHobby = root.GetProperty("hobbies")[0].GetString();

// 값 수정, 추가, 삭제는 직접 지원하지 않음
// 새로운 JSON 문서를 만들어야 함
var options = new JsonWriterOptions { Indented = true };
using var stream = new MemoryStream();
using var writer = new Utf8JsonWriter(stream, options);

writer.WriteStartObject();
writer.WriteString("name", name);
writer.WriteNumber("age", 31); // 수정된 값
writer.WriteStartObject("address");
writer.WriteString("city", "부산"); // 수정된 값
writer.WriteString("zipcode", root.GetProperty("address").GetProperty("zipcode").GetString());
writer.WriteEndObject();
writer.WriteBoolean("isStudent", false); // 새로 추가된 속성
writer.WriteEndObject();

writer.Flush();
string modifiedJson = Encoding.UTF8.GetString(stream.ToArray());

보시다시피, System.Text.Json으로 JSON 데이터를 수정하는 것은 훨씬 더 복잡하고 장황해요. 이건 진짜 큰 단점 중 하나예요! 😅

7.2 JSON 스키마 검증

7.2.1 Newtonsoft.Json

Newtonsoft.Json은 JSON 스키마 검증을 위한 확장 패키지(Newtonsoft.Json.Schema)를 제공해요.

// NuGet 패키지 설치: Install-Package Newtonsoft.Json.Schema

string schemaJson = @"{
  'type': 'object',
  'properties': {
    'name': { 'type': 'string' },
    'age': { 'type': 'integer', 'minimum': 0 },
    'hobbies': { 'type': 'array', 'items': { 'type': 'string' } }
  },
  'required': ['name', 'age']
}";

JSchema schema = JSchema.Parse(schemaJson);
JObject person = JObject.Parse(@"{ 'name': '홍길동', 'age': 30, 'hobbies': ['코딩', '게임'] }");

bool isValid = person.IsValid(schema);
// isValid는 true

JObject invalidPerson = JObject.Parse(@"{ 'name': '홍길동', 'age': -5 }");
isValid = invalidPerson.IsValid(schema, out IList<string> errorMessages);
// isValid는 false, errorMessages에 오류 내용이 포함됨

7.2.2 System.Text.Json

System.Text.Json은 현재 JSON 스키마 검증을 직접 지원하지 않아요. 서드파티 라이브러리(예: NJsonSchema)를 사용해야 해요.

// NuGet 패키지 설치: Install-Package NJsonSchema

string schemaJson = @"{
  'type': 'object',
  'properties': {
    'name': { 'type': 'string' },
    'age': { 'type': 'integer', 'minimum': 0 },
    'hobbies': { 'type': 'array', 'items': { 'type': 'string' } }
  },
  'required': ['name', 'age']
}";

var schema = NJsonSchema.JsonSchema.FromJsonAsync(schemaJson).Result;
var person = System.Text.Json.JsonDocument.Parse(@"{ 'name': '홍길동', 'age': 30, 'hobbies': ['코딩', '게임'] }");

var errors = schema.Validate(person.RootElement.GetRawText());
bool isValid = errors.Count == 0;
// isValid는 true

7.3 JSON 패치(JSON Patch)

7.3.1 Newtonsoft.Json

Newtonsoft.Json은 JSON 패치 기능을 제공해요. JSON 패치는 JSON 문서의 부분적인 업데이트를 위한 표준 형식이에요.

// NuGet 패키지 설치: Install-Package Newtonsoft.Json

JObject person = JObject.Parse(@"{ 'name': '홍길동', 'age': 30, 'hobbies': ['코딩', '게임'] }");

JsonPatchDocument patch = new JsonPatchDocument();
patch.Replace("/age", 31);
patch.Add("/address", new JObject(new JProperty("city", "서울")));
patch.Remove("/hobbies/1"); // '게임' 제거

patch.ApplyTo(person);
// 결과: { 'name': '홍길동', 'age': 31, 'hobbies': ['코딩'], 'address': { 'city': '서울' } }

7.3.2 System.Text.Json

System.Text.Json은 JSON 패치를 직접 지원하지 않아요. ASP.NET Core에서는 Microsoft.AspNetCore.JsonPatch 패키지를 사용할 수 있어요.

// NuGet 패키지 설치: Install-Package Microsoft.AspNetCore.JsonPatch

var person = new Person
{
    Name = "홍길동",
    Age = 30,
    Hobbies = new List<string> { "코딩", "게임" }
};

var patch = new JsonPatchDocument<Person>();
patch.Replace(p => p.Age, 31);
// 주의: JsonPatchDocument는 복잡한 추가/삭제 작업에 제한이 있음

patch.ApplyTo(person);
// person.Age는 31로 변경됨

7.4 동적 타입(Dynamic) 지원

7.4.1 Newtonsoft.Json

Newtonsoft.Json은 C#의 dynamic 타입을 완벽하게 지원해요.

string json = @"{ 'name': '홍길동', 'age': 30, 'address': { 'city': '서울' } }";

// dynamic 타입으로 역직렬화
dynamic person = JsonConvert.DeserializeObject(json);

// 속성에 쉽게 접근
string name = person.name;
int age = person.age;
string city = person.address.city;

// 속성 수정
person.age = 31;
person.address.city = "부산";

// 다시 JSON으로 직렬화
string modifiedJson = JsonConvert.SerializeObject(person);

7.4.2 System.Text.Json

System.Text.Json은 dynamic 타입을 직접 지원하지 않아요. JsonDocument나 JsonElement를 사용해야 해요.

string json = @"{ 'name': '홍길동', 'age': 30, 'address': { 'city': '서울' } }";

// JsonDocument로 파싱
using JsonDocument doc = JsonDocument.Parse(json);
JsonElement root = doc.RootElement;

// 속성에 접근
string name = root.GetProperty("name").GetString();
int age = root.GetProperty("age").GetInt32();
string city = root.GetProperty("address").GetProperty("city").GetString();

// 속성 수정은 직접 지원하지 않음

동적 타입 지원은 Newtonsoft.Json이 훨씬 편리해요. System.Text.Json은 이 부분에서 많이 제한적이에요.

7.5 커스텀 컨트랙트 리졸버(Contract Resolver)

7.5.1 Newtonsoft.Json

Newtonsoft.Json은 커스텀 컨트랙트 리졸버를 통해 직렬화/역직렬화 동작을 세밀하게 제어할 수 있어요.

public class LowercaseContractResolver : DefaultContractResolver
{
    protected override string ResolvePropertyName(string propertyName)
    {
        return propertyName.ToLower();
    }
}

var settings = new JsonSerializerSettings
{
    ContractResolver = new LowercaseContractResolver()
};

var person = new Person { Name = "홍길동", Age = 30 };
string json = JsonConvert.SerializeObject(person, settings);
// 결과: {"name":"홍길동","age":30}

7.5.2 System.Text.Json

System.Text.Json은 컨트랙트 리졸버 개념이 없어요. 대신 JsonSerializerOptions와 커스텀 컨버터를 사용해야 해요.

public class LowercaseNamingPolicy : JsonNamingPolicy
{
    public override string ConvertName(string name)
    {
        return name.ToLower();
    }
}

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = new LowercaseNamingPolicy()
};

var person = new Person { Name = "홍길동", Age = 30 };
string json = JsonSerializer.Serialize(person, options);
// 결과: {"name":"홍길동","age":30}

System.Text.Json의 접근 방식은 더 제한적이지만, 간단한 사용 사례에는 충분해요.

고급 기능 측면에서는 Newtonsoft.Json이 압도적으로 더 많은 기능과 유연성을 제공해요. 복잡한 JSON 처리가 필요한 프로젝트라면 Newtonsoft.Json이 더 적합할 수 있어요! 🛠️

8. 마이그레이션 가이드 🚚

Newtonsoft.Json에서 System.Text.Json으로 마이그레이션하려는 분들을 위한 가이드를 준비했어요! 이거 진짜 필요한 분들 많을 거예요. ㅋㅋㅋ

8.1 기본 직렬화/역직렬화 코드 변경

Newtonsoft.Json:

using Newtonsoft.Json;

// 직렬화
string json = JsonConvert.SerializeObject(obj);

// 역직렬화
MyClass obj = JsonConvert.DeserializeObject<MyClass>(json);

System.Text.Json:

using System.Text.Json;

// 직렬화
string json = JsonSerializer.Serialize(obj);

// 역직렬화
MyClass obj = JsonSerializer.Deserialize<MyClass>(json);

8.2 옵션 설정 변경

Newtonsoft.Json:

var settings = new JsonSerializerSettings
{
    Formatting = Formatting.Indented,
    NullValueHandling = NullValueHandling.Ignore,
    ContractResolver = new CamelCasePropertyNamesContractResolver(),
    DateFormatString = "yyyy-MM-dd"
};

string json = JsonConvert.SerializeObject(obj, settings);

System.Text.Json:

var options = new JsonSerializerOptions
{
    WriteIndented = true,
    IgnoreNullValues = true, // .NET 5.0 이하
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, // .NET 6.0 이상
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    // DateFormatString 직접 지원 안 함 -> 커스텀 컨버터 필요
};

string json = JsonSerializer.Serialize(obj, options);

8.3 속성 어트리뷰트 변경

Newtonsoft.Json:

public class Person
{
    [JsonProperty("full_name")]
    public string Name { get; set; }
    
    [JsonIgnore]
    public int SecretValue { get; set; }
    
    [JsonRequired]
    public int Age { get; set; }
}

System.Text.Json:

public class Person
{
    [JsonPropertyName("full_name")]
    public string Name { get; set; }
    
    [JsonIgnore]
    public int SecretValue { get; set; }
    
    // JsonRequired 직접 지원 안 함
    public int Age { get; set; }
}

8.4 커스텀 컨버터 변경

Newtonsoft.Json:

public class DateTimeConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(DateTime);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        string dateString = (string)reader.Value;
        return DateTime.ParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        DateTime date = (DateTime)value;
        writer.WriteValue(date.ToString("yyyy-MM-dd"));
    }
}

System.Text.Json:

public class DateTimeConverter : JsonConverter<DateTime>
{
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        string dateString = reader.GetString();
        return DateTime.ParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture);
    }

    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value.ToString("yyyy-MM-dd"));
    }
}

8.5 마이그레이션 시 주의사항

1. 대소문자 구분: Newtonsoft.Json은 기본적으로 대소문자를 구분하지 않지만, System.Text.Json은 구분해요. PropertyNameCaseInsensitive 옵션을 true로 설정해야 해요.
2. 순환 참조: System.Text.Json은 .NET 6.0 이전에는 순환 참조를 처리하기 어려워요. 객체 그래프를 수정하거나 .NET 6.0 이상으로 업그레이드해야 해요.
3. 동적 타입: System.Text.Json은 dynamic 타입을 직접 지원하지 않아요. JsonDocument나 JsonElement를 사용해야 해요.
4. 날짜 형식: System.Text.Json은 날짜 형식을 직접 지정하는 옵션이 없어요. 커스텀 컨버터를 구현해야 해요.
5. LINQ to JSON: System.Text.Json은 LINQ to JSON과 같은 기능을 제공하지 않아요. 코드를 크게 수정해야 할 수 있어요.

8.6 마이그레이션 도구

마이크로소프트에서는 Newtonsoft.Json에서 System.Text.Json으로의 마이그레이션을 돕기 위한 분석기를 제공해요.

// NuGet 패키지 설치
Install-Package Microsoft.DotNet.Analyzers.Compatibility

이 분석기는 Newtonsoft.Json API 사용을 감지하고, System.Text.Json으로 변경하는 방법에 대한 제안을 제공해요.

마이그레이션은 쉽지 않은 작업일 수 있어요. 특히 Newtonsoft.Json의 고급 기능을 많이 사용하는 프로젝트라면 더욱 그래요. 점진적으로 마이그레이션하거나, 성능이 중요한 부분만 선택적으로 마이그레이션하는 것도 좋은 전략이에요! 🧠

9. 실제 프로젝트에서의 선택 기준 🤔

자, 이제 두 라이브러리에 대해 많이 알게 되셨을 텐데요. 실제 프로젝트에서는 어떤 라이브러리를 선택해야 할까요? 여기 몇 가지 고려사항을 정리해봤어요!

9.1 System.Text.Json을 선택해야 하는 경우

1. 성능이 중요한 경우: 대용량 JSON 데이터를 처리하거나, 고성능이 요구되는 애플리케이션이라면 System.Text.Json이 더 적합해요.
2. 메모리 사용량이 중요한 경우: 제한된 리소스 환경에서 실행되는 애플리케이션이라면 System.Text.Json의 낮은 메모리 사용량이 유리해요.
3. 새 프로젝트를 시작하는 경우: 새로운 .NET Core/.NET 5+ 프로젝트라면, 마이크로소프트의 공식 라이브러리인 System.Text.Json을 사용하는 것이 좋아요.
4. 외부 종속성을 최소화하고 싶은 경우: System.Text.Json은 .NET Core 3.0 이상에서는 내장 라이브러리이므로 추가 패키지가 필요 없어요.
5. 비동기 API가 중요한 경우: System.Text.Json은 처음부터 비동기 API를 고려하여 설계되었어요.

9.2 Newtonsoft.Json을 선택해야 하는 경우

1. 고급 기능이 필요한 경우: LINQ to JSON, 다양한 직렬화 옵션, 커스텀 컨트랙트 리졸버 등 고급 기능이 필요하다면 Newtonsoft.Json이 더 적합해요.
2. 레거시 프로젝트를 유지보수하는 경우: 이미 Newtonsoft.Json을 사용하고 있는 프로젝트라면, 마이그레이션 비용을 고려해야 해요.
3. 복잡한 객체 그래프를 다루는 경우: 순환 참조가 있는 복잡한 객체 그래프를 다룬다면, Newtonsoft.Json이 더 쉽게 처리할 수 있어요.
4. 동적 타입(dynamic)을 많이 사용하는 경우: dynamic 타입을 많이 사용한다면 Newtonsoft.Json이 더 편리해요.
5. .NET Framework를 사용하는 경우: .NET Framework 프로젝트에서는 Newtonsoft.Json이 더 안정적이고 호환성이 좋아요.

9.3 실제 사례 분석

몇 가지 실제 사례를 통해 어떤 라이브러리가 더 적합한지 살펴볼게요:

9.3.1 웹 API 서버

대용량 트래픽을 처리하는 웹 API 서버의 경우:

• 성능과 메모리 사용량이 중요하므로 System.Text.Json이 유리해요.
• 하지만 복잡한 JSON 변환이 많다면 Newtonsoft.Json의 유연성이 필요할 수 있어요.
• ASP.NET Core 3.0 이상에서는 기본적으로 System.Text.Json을 사용해요.

9.3.2 데이터 처리 애플리케이션

대용량 JSON 데이터를 처리하는 애플리케이션의 경우:

• 처리 속도가 중요하므로 System.Text.Json이 유리해요.
• 하지만 복잡한 데이터 변환이나 쿼리가 필요하다면 Newtonsoft.Json의 LINQ to JSON이 유용해요.

9.3.3 클라이언트 애플리케이션

데스크톱이나 모바일 클라이언트 애플리케이션의 경우:

• JSON 처리량이 상대적으로 적으므로 라이브러리 선택의 영향이 적어요.
• 개발 편의성과 기능성을 고려하면 Newtonsoft.Json이 좋을 수 있어요.
• 하지만 새로운 프로젝트라면 System.Text.Json을 사용하는 것이 미래 지향적이에요.

재능넷에서 C# 개발 관련 재능을 찾고 계신다면, 이런 기술적 선택에 대한 조언도 함께 받아보세요! 프로젝트의 특성에 맞는 최적의 라이브러리 선택은 개발 효율성과 성능에 큰 영향을 미칠 수 있어요. 🌟

결국 어떤 라이브러리를 선택할지는 프로젝트의 요구사항, 개발 팀의 경험, 성능 요구사항 등을 종합적으로 고려해야 해요. 두 라이브러리 모두 훌륭한 선택이 될 수 있어요! 🎯

10. 결론 및 요약 📝

지금까지 C#에서 JSON을 다루는 두 가지 주요 라이브러리인 System.Text.Json과 Newtonsoft.Json(Json.NET)을 비교해봤어요. 정말 길고 자세한 여정이었죠? ㅋㅋㅋ 이제 마지막으로 핵심 내용을 요약해볼게요!

10.1 주요 차이점 요약

10.2 최종 권장사항

System.Text.Json 사용이 권장되는 경우:

• 새로운 .NET Core/.NET 5+ 프로젝트
• 성능과 메모리 효율성이 중요한 경우
• 간단한 JSON 직렬화/역직렬화 요구사항
• 마이크로소프트 생태계와의 통합이 중요한 경우

Newtonsoft.Json 사용이 권장되는 경우:

• 복잡한 JSON 처리 요구사항이 있는 경우
• 레거시 .NET Framework 프로젝트
• 동적 타입, LINQ to JSON 등의 고급 기능이 필요한 경우
• 기존 Newtonsoft.Json 코드베이스가 있는 경우

10.3 미래 전망

Microsoft는 System.Text.Json을 계속 개선하고 있어요. 각 .NET 버전마다 새로운 기능이 추가되고 있죠. 장기적으로는 System.Text.Json이 Newtonsoft.Json의 대부분의 기능을 제공할 것으로 예상돼요.

하지만 Newtonsoft.Json도 여전히 활발하게 개발되고 있고, 커뮤니티의 지원도 강력해요. 두 라이브러리는 앞으로도 공존할 가능성이 높아요.

결국, 라이브러리 선택은 프로젝트의 구체적인 요구사항에 따라 달라져요. 어떤 것이 "더 좋다"라고 단정짓기보다는, 각 프로젝트에 "더 적합한" 라이브러리를 선택하는 것이 중요해요!

재능넷에서는 다양한 C# 개발 관련 재능을 만나볼 수 있어요. JSON 처리뿐만 아니라 다양한 개발 영역에서 전문가들의 도움을 받아보세요! 여러분의 프로젝트에 가장 적합한 기술 선택을 통해 개발 효율성을 높이고, 더 나은 결과물을 만들어보세요. 🚀

이 글이 여러분의 C# JSON 라이브러리 선택에 도움이 되었길 바라요! 궁금한 점이나 추가 정보가 필요하시면 언제든지 질문해주세요! 감사합니다! 😊