【C#】JSON文字列をSerialize・Deserializeで高速変換する方法と実用例

using System;
using System.Text.Json;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        // JSON文字列をオブジェクトに変換(デシリアライズ)
        string jsonString = "{\"Name\":\"Alice\",\"Age\":30}";
        Person person = JsonSerializer.Deserialize<Person>(jsonString);
        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
        // オブジェクトをJSON文字列に変換(シリアライズ)
        string serialized = JsonSerializer.Serialize(person);
        Console.WriteLine(serialized);
    }
}

Name: Alice, Age: 30
{"Name":"Alice","Age":30}

using System;
using Newtonsoft.Json;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        // JSON文字列をオブジェクトに変換(デシリアライズ)
        string jsonString = "{\"Name\":\"Alice\",\"Age\":30}";
        Person person = JsonConvert.DeserializeObject<Person>(jsonString);
        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
        // オブジェクトをJSON文字列に変換(シリアライズ)
        string serialized = JsonConvert.SerializeObject(person);
        Console.WriteLine(serialized);
    }
}

Name: Alice, Age: 30
{"Name":"Alice","Age":30}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Age = 30 };
        // オブジェクトをJSON文字列に変換
        string jsonString = JsonSerializer.Serialize(person);
        Console.WriteLine(jsonString);
    }
}

{"Name":"Alice","Age":30}

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Age = 30 };
        var options = new JsonSerializerOptions
        {
            WriteIndented = true // インデント付きで出力
        };
        string jsonString = JsonSerializer.Serialize(person, options);
        Console.WriteLine(jsonString);
    }
}

{
  "Name": "Alice",
  "Age": 30
}

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Age = 30 };
        var options = new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        };
        string jsonString = JsonSerializer.Serialize(person, options);
        Console.WriteLine(jsonString);
    }
}

{"name":"Alice","age":30}

using System;
using System.Text.Json;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        string jsonString = "{\"Name\":\"Alice\",\"Age\":30}";
        // JSON文字列をPersonオブジェクトに変換
        Person person = JsonSerializer.Deserialize<Person>(jsonString);
        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
    }
}

Name: Alice, Age: 30

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        string invalidJson = "{\"Name\":\"Alice\",\"Age\":\"thirty\"}"; // Ageが文字列で不正
        try
        {
            Person person = JsonSerializer.Deserialize<Person>(invalidJson);
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"JSONの解析エラー: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"その他のエラー: {ex.Message}");
        }
    }
}

JSONの解析エラー: The JSON value could not be converted to System.Int32. Path: $.Age | LineNumber: 0 | BytePositionInLine: 24.

using System;
using System.Text.Json;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        string malformedJson = "{\"Name\":\"Alice\",\"Age\":30"; // 閉じ括弧がない
        try
        {
            Person person = JsonSerializer.Deserialize<Person>(malformedJson);
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"不正なJSONです: {ex.Message}");
        }
    }
}

不正なJSONです: '0' is an invalid end of a number. Expected a delimiter. Path: $.Age | LineNumber: 0 | BytePositionInLine: 24.

using System;
using System.Text.Json;

class Program
{
    static void Main()
    {
        string json = "{\"Name\":\"Alice\",\"Age\":30}";

        try
        {
            // JsonDocument を生成しつつ、スコープ終了時に自動破棄する
            using (JsonDocument doc = JsonDocument.Parse(json))
            {
                // ここでは特に処理せず、パースチェックだけ行う
            }

            Console.WriteLine("JSONは正しい形式です。");
        }
        catch (JsonException)
        {
            Console.WriteLine("JSONが不正です。");
        }
    }
}

JSONは正しい形式です。

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Person
{
    [JsonPropertyName("full_name")]
    public string Name { get; set; }
    [JsonPropertyName("age_in_years")]
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Age = 30 };
        string jsonString = JsonSerializer.Serialize(person);
        Console.WriteLine(jsonString);
        // JSON文字列をデシリアライズする際も属性が適用される
        string jsonInput = "{\"full_name\":\"Bob\",\"age_in_years\":25}";
        Person deserialized = JsonSerializer.Deserialize<Person>(jsonInput);
        Console.WriteLine($"Name: {deserialized.Name}, Age: {deserialized.Age}");
    }
}

{"full_name":"Alice","age_in_years":30}
Name: Bob, Age: 25

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Person
{
    public string Name { get; set; }
    [JsonIgnore]
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Age = 30 };
        string jsonString = JsonSerializer.Serialize(person);
        Console.WriteLine(jsonString);
        // AgeはJSONに含まれないため、デシリアライズ時も無視される
        string jsonInput = "{\"Name\":\"Bob\",\"Age\":25}";
        Person deserialized = JsonSerializer.Deserialize<Person>(jsonInput);
        Console.WriteLine($"Name: {deserialized.Name}, Age: {deserialized.Age}"); // Ageはデフォルト値0
    }
}

{"Name":"Alice"}
Name: Bob, Age: 0

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Person
{
    public string Name { get; set; }
    public string? Nickname { get; set; }
}
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Nickname = null };
        var options = new JsonSerializerOptions
        {
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
        };
        string jsonString = JsonSerializer.Serialize(person, options);
        Console.WriteLine(jsonString);
    }
}

{"Name":"Alice"}

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; } = 0;
    public bool IsActive { get; set; } = true;
}
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Age = 0, IsActive = true };
        var options = new JsonSerializerOptions
        {
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault,
            WriteIndented = true
        };
        string jsonString = JsonSerializer.Serialize(person, options);
        Console.WriteLine(jsonString);
    }
}

{
  "Name": "Alice"
}

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Temperature
{
    public int Degrees { get; set; }
    public bool IsCelsius { get; set; }
    public override string ToString() => $"{Degrees}{(IsCelsius ? "C" : "F")}";
}
public class TemperatureConverter : JsonConverter<Temperature>
{
    public override Temperature Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        // JSONの値は文字列形式(例: "25C" または "77F")と想定
        string value = reader.GetString();
        int degrees = int.Parse(value.Substring(0, value.Length - 1));
        bool isCelsius = value.EndsWith("C");
        return new Temperature { Degrees = degrees, IsCelsius = isCelsius };
    }
    public override void Write(Utf8JsonWriter writer, Temperature value, JsonSerializerOptions options)
    {
        // Writeメソッドは後述
        throw new NotImplementedException();
    }
}

public override void Write(Utf8JsonWriter writer, Temperature value, JsonSerializerOptions options)
{
    // Temperatureオブジェクトを "25C" のような文字列に変換して書き込む
    writer.WriteStringValue(value.ToString());
}

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class WeatherForecast
{
    public DateTime Date { get; set; }
    [JsonConverter(typeof(TemperatureConverter))]
    public Temperature Temperature { get; set; }
}
class Program
{
    static void Main()
    {
        WeatherForecast forecast = new WeatherForecast
        {
            Date = DateTime.Now,
            Temperature = new Temperature { Degrees = 25, IsCelsius = true }
        };
        string jsonString = JsonSerializer.Serialize(forecast);
        Console.WriteLine(jsonString);
        WeatherForecast deserialized = JsonSerializer.Deserialize<WeatherForecast>(jsonString);
        Console.WriteLine($"Date: {deserialized.Date}, Temperature: {deserialized.Temperature}");
    }
}

{"Date":"2024-06-01T12:00:00","Temperature":"25C"}
Date: 2024/06/01 12:00:00, Temperature: 25C

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
class Program
{
    static void Main()
    {
        var options = new JsonSerializerOptions();
        options.Converters.Add(new TemperatureConverter());
        WeatherForecast forecast = new WeatherForecast
        {
            Date = DateTime.Now,
            Temperature = new Temperature { Degrees = 25, IsCelsius = true }
        };
        string jsonString = JsonSerializer.Serialize(forecast, options);
        Console.WriteLine(jsonString);
        WeatherForecast deserialized = JsonSerializer.Deserialize<WeatherForecast>(jsonString, options);
        Console.WriteLine($"Date: {deserialized.Date}, Temperature: {deserialized.Temperature}");
    }
}

{"Date":"2024-06-01T12:00:00","Temperature":"25C"}
Date: 2024/06/01 12:00:00, Temperature: 25C

using System;
using System.Collections.Generic;
using System.Text.Json;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        var people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };
        string jsonString = JsonSerializer.Serialize(people, new JsonSerializerOptions { WriteIndented = true });
        Console.WriteLine(jsonString);
    }
}

[
  {
    "Name": "Alice",
    "Age": 30
  },
  {
    "Name": "Bob",
    "Age": 25
  }
]

using System;
using System.Collections.Generic;
using System.Text.Json;
class Program
{
    static void Main()
    {
        var dict = new Dictionary<string, int>
        {
            { "apple", 3 },
            { "banana", 5 }
        };
        string jsonString = JsonSerializer.Serialize(dict, new JsonSerializerOptions { WriteIndented = true });
        Console.WriteLine(jsonString);
    }
}

{
  "apple": 3,
  "banana": 5
}

using System;
using System.Collections.Generic;
using System.Text.Json;
class Program
{
    static void Main()
    {
        var dict = new Dictionary<int, string>
        {
            { 1, "one" },
            { 2, "two" }
        };
        try
        {
            string jsonString = JsonSerializer.Serialize(dict);
            Console.WriteLine(jsonString);
        }
        catch (NotSupportedException ex)
        {
            Console.WriteLine($"エラー: {ex.Message}");
        }
    }
}

エラー: The collection type 'System.Collections.Generic.Dictionary`2[System.Int32,System.String]' is not supported.

using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
public class IntKeyDictionaryConverter<TValue> : JsonConverter<Dictionary<int, TValue>>
{
    public override Dictionary<int, TValue> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        var dict = new Dictionary<int, TValue>();
        if (reader.TokenType != JsonTokenType.StartObject)
            throw new JsonException();
        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.EndObject)
                return dict;
            string propertyName = reader.GetString();
            if (!int.TryParse(propertyName, out int key))
                throw new JsonException($"キー '{propertyName}' は整数に変換できません。");
            reader.Read();
            TValue value = JsonSerializer.Deserialize<TValue>(ref reader, options);
            dict.Add(key, value);
        }
        throw new JsonException();
    }
    public override void Write(Utf8JsonWriter writer, Dictionary<int, TValue> value, JsonSerializerOptions options)
    {
        writer.WriteStartObject();
        foreach (var kvp in value)
        {
            writer.WritePropertyName(kvp.Key.ToString());
            JsonSerializer.Serialize(writer, kvp.Value, options);
        }
        writer.WriteEndObject();
    }
}
class Program
{
    static void Main()
    {
        var dict = new Dictionary<int, string>
        {
            { 1, "one" },
            { 2, "two" }
        };
        var options = new JsonSerializerOptions();
        options.Converters.Add(new IntKeyDictionaryConverter<string>());
        string jsonString = JsonSerializer.Serialize(dict, options);
        Console.WriteLine(jsonString);
        var deserialized = JsonSerializer.Deserialize<Dictionary<int, string>>(jsonString, options);
        foreach (var kvp in deserialized)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

{"1":"one","2":"two"}
Key: 1, Value: one
Key: 2, Value: two

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.UtcNow;
        string jsonString = JsonSerializer.Serialize(now);
        Console.WriteLine(jsonString);
    }
}

"2024-06-01T03:45:30.1234567Z"

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Globalization;
public class CustomDateTimeConverter : JsonConverter<DateTime>
{
    private const string Format = "yyyy/MM/dd HH:mm:ss";
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        string? value = reader.GetString();
        if (value == null)
            throw new JsonException("日時文字列がnullです。");
        return DateTime.ParseExact(value, Format, CultureInfo.InvariantCulture);
    }
    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value.ToString(Format));
    }
}
class Program
{
    public class Event
    {
        [JsonConverter(typeof(CustomDateTimeConverter))]
        public DateTime EventDate { get; set; }
    }
    static void Main()
    {
        var evt = new Event { EventDate = new DateTime(2024, 6, 1, 15, 30, 0) };
        string jsonString = JsonSerializer.Serialize(evt);
        Console.WriteLine(jsonString);
        var deserialized = JsonSerializer.Deserialize<Event>(jsonString);
        Console.WriteLine($"Deserialized Date: {deserialized?.EventDate}");
    }
}

{"EventDate":"2024/06/01 15:30:00"}
Deserialized Date: 6/1/2024 3:30:00 PM

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        string text = "Hello \"World\"\nNew line";
        string jsonString = JsonSerializer.Serialize(text);
        Console.WriteLine(jsonString);
    }
}

"Hello \"World\"\nNew line"

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        string japaneseText = "こんにちは、世界！";
        string jsonString = JsonSerializer.Serialize(japaneseText);
        Console.WriteLine(jsonString);
        string deserialized = JsonSerializer.Deserialize<string>(jsonString);
        Console.WriteLine(deserialized);
    }
}

"こんにちは、世界！"
こんにちは、世界！

using System;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static async Task Main()
    {
        Person person = new Person { Name = "Alice", Age = 30 };
        using FileStream fs = new FileStream("person.json", FileMode.Create, FileAccess.Write, FileShare.None, 4096, useAsync: true);
        // 非同期でJSONを書き込む
        await JsonSerializer.SerializeAsync(fs, person);
        Console.WriteLine("JSONの書き込みが完了しました。");
    }
}

using System;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static async Task Main()
    {
        using FileStream fs = new FileStream("person.json", FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: true);
        // 非同期でJSONを読み込み、Personオブジェクトに変換
        Person person = await JsonSerializer.DeserializeAsync<Person>(fs);
        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
    }
}

using System;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static async Task Main()
    {
        Person person = new Person { Name = "Bob", Age = 40 };
        using MemoryStream ms = new MemoryStream();
        // メモリストリームに非同期でシリアライズ
        await JsonSerializer.SerializeAsync(ms, person);
        // ストリームの位置を先頭に戻す
        ms.Position = 0;
        // メモリストリームから非同期でデシリアライズ
        Person deserialized = await JsonSerializer.DeserializeAsync<Person>(ms);
        Console.WriteLine($"Name: {deserialized.Name}, Age: {deserialized.Age}");
    }
}

Name: Bob, Age: 40

var options = new JsonSerializerOptions
{
    DefaultBufferSize = 32 * 1024 // 32KBに設定
};

var options = new JsonSerializerOptions
{
    DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
};

var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true
};

var options = new JsonSerializerOptions
{
    WriteIndented = false
};

using System.Buffers;
byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
try
{
    // bufferを使った処理
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);
}

using System.Buffers;
using System.Text.Json;
var buffer = new ArrayBufferWriter<byte>();
var writer = new Utf8JsonWriter(buffer);
// JSON書き込み処理
writer.WriteStartObject();
writer.WriteString("Name", "Alice");
writer.WriteNumber("Age", 30);
writer.WriteEndObject();
writer.Flush();
string json = System.Text.Encoding.UTF8.GetString(buffer.WrittenSpan);
Console.WriteLine(json);

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var person = new Person { Name = "Alice", Age = 30 };
        string jsonRequest = JsonSerializer.Serialize(person);
        var content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
        // POSTリクエストでJSONを送信
        HttpResponseMessage response = await client.PostAsync("https://example.com/api/person", content);
        response.EnsureSuccessStatusCode();
        // レスポンスのJSONを文字列で取得
        string jsonResponse = await response.Content.ReadAsStringAsync();
        // JSONをPersonオブジェクトにデシリアライズ
        Person responsePerson = JsonSerializer.Deserialize<Person>(jsonResponse);
        Console.WriteLine($"Received: Name={responsePerson.Name}, Age={responsePerson.Age}");
    }
}

Received: Name=Alice, Age=30

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
// ビジネスモデル
public class User
{
    public string FullName { get; set; }
    public int Age { get; set; }
}
// API用DTO
public class UserDto
{
    public string name { get; set; }
    public int age { get; set; }
}
class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        // ビジネスモデルのインスタンス
        User user = new User { FullName = "Bob Smith", Age = 40 };
        // DTOに変換(マッピング)
        UserDto dto = new UserDto
        {
            name = user.FullName,
            age = user.Age
        };
        string jsonRequest = JsonSerializer.Serialize(dto);
        var content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
        HttpResponseMessage response = await client.PostAsync("https://example.com/api/user", content);
        response.EnsureSuccessStatusCode();
        string jsonResponse = await response.Content.ReadAsStringAsync();
        // APIレスポンスをDTOで受け取る
        UserDto responseDto = JsonSerializer.Deserialize<UserDto>(jsonResponse);
        // DTOからビジネスモデルに変換
        User responseUser = new User
        {
            FullName = responseDto.name,
            Age = responseDto.age
        };
        Console.WriteLine($"Received User: FullName={responseUser.FullName}, Age={responseUser.Age}");
    }
}

Received User: FullName=Bob Smith, Age=40

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        string jsonString = @"{
            ""Name"": ""Alice"",
            ""Age"": 30,
            ""Skills"": [""C#"", ""JSON"", ""ASP.NET""]
        }";
        using JsonDocument doc = JsonDocument.Parse(jsonString);
        JsonElement root = doc.RootElement;
        Console.WriteLine($"Name: {root.GetProperty("Name").GetString()}");
        Console.WriteLine($"Age: {root.GetProperty("Age").GetInt32()}");
    }
}

Name: Alice
Age: 30

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        string jsonString = @"{ ""Name"": ""Bob"" }";
        using JsonDocument doc = JsonDocument.Parse(jsonString);
        JsonElement root = doc.RootElement;
        if (root.TryGetProperty("Age", out JsonElement ageElement))
        {
            Console.WriteLine($"Age: {ageElement.GetInt32()}");
        }
        else
        {
            Console.WriteLine("Ageプロパティは存在しません。");
        }
    }
}

Ageプロパティは存在しません。

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        string jsonString = @"{ ""Skills"": [""C#"", ""JSON"", ""ASP.NET""] }";
        using JsonDocument doc = JsonDocument.Parse(jsonString);
        JsonElement root = doc.RootElement;
        JsonElement skills = root.GetProperty("Skills");
        foreach (JsonElement skill in skills.EnumerateArray())
        {
            Console.WriteLine(skill.GetString());
        }
    }
}

C#
JSON
ASP.NET

using System;
using System.Text.Json;
class Program
{
    static void Main()
    {
        string jsonString = @"{ ""Value"": 123 }";
        using JsonDocument doc = JsonDocument.Parse(jsonString);
        JsonElement root = doc.RootElement;
        JsonElement value = root.GetProperty("Value");
        switch (value.ValueKind)
        {
            case JsonValueKind.Number:
                Console.WriteLine($"数値: {value.GetInt32()}");
                break;
            case JsonValueKind.String:
                Console.WriteLine($"文字列: {value.GetString()}");
                break;
            default:
                Console.WriteLine("その他の型");
                break;
        }
    }
}

数値: 123

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Node
{
    public string Name { get; set; }
    public Node Next { get; set; }
}
class Program
{
    static void Main()
    {
        var node1 = new Node { Name = "Node1" };
        var node2 = new Node { Name = "Node2", Next = node1 };
        node1.Next = node2; // 循環参照
        try
        {
            string json = JsonSerializer.Serialize(node1);
            Console.WriteLine(json);
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"循環参照エラー: {ex.Message}");
        }
    }
}

循環参照エラー: A possible object cycle was detected. This can either be due to a cycle or if the object depth is larger than the maximum allowed depth of 64. Consider using ReferenceHandler.Preserve on JsonSerializerOptions to support cycles. Path: $.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Next.Name.

var options = new JsonSerializerOptions
{
    ReferenceHandler = ReferenceHandler.Preserve,
    WriteIndented = true
};
string json = JsonSerializer.Serialize(node1, options);
Console.WriteLine(json);

using System;
using System.Text.Json;
public class Person
{
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        string json = "{\"Age\":\"thirty\"}";
        try
        {
            Person person = JsonSerializer.Deserialize<Person>(json);
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"型不一致エラー: {ex.Message}");
        }
    }
}

型不一致エラー: The JSON value could not be converted to System.Int32. Path: $.Age | LineNumber: 0 | BytePositionInLine: 15.

using System;
using System.Text.Json;
public class Person
{
    public string Name { get; set; }
}
class Program
{
    static void Main()
    {
        string json = "{\"name\":\"Alice\"}"; // 小文字の"name"
        Person person = JsonSerializer.Deserialize<Person>(json);
        Console.WriteLine($"Name: {person.Name ?? "null"}"); // nullになる
    }
}

Name: null

var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true
};
Person person = JsonSerializer.Deserialize<Person>(json, options);
Console.WriteLine($"Name: {person.Name}");

Name: Alice

using System;
using System.Text.Json;
public class Data
{
    public int Number { get; set; }
}
class Program
{
    static void Main()
    {
        string json = "{\"Number\": 12.34}"; // double値
        try
        {
            Data data = JsonSerializer.Deserialize<Data>(json);
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"暗黙型変換エラー: {ex.Message}");
        }
    }
}

暗黙型変換エラー: The JSON value could not be converted to System.Int32. Path: $.Number | LineNumber: 0 | BytePositionInLine: 16.

using System;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        using FileStream fs = new FileStream("large.json", FileMode.Open, FileAccess.Read);
        var options = new JsonSerializerOptions
        {
            // 必要に応じてオプションを設定
        };
        try
        {
            var document = await JsonDocument.ParseAsync(fs);
            // JSONの内容を部分的に検証・処理
            if (document.RootElement.GetArrayLength() > 1000)
            {
                Console.WriteLine("配列の要素数が多すぎます。処理を中止します。");
                return;
            }
            // 続けて処理
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"不正なJSONです: {ex.Message}");
        }
    }
}

using System.Text.Json.Serialization;
[JsonSerializable(typeof(Person))]
public partial class PersonJsonContext : JsonSerializerContext
{
}
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
// シリアライズ・デシリアライズ時にコンテキストを指定
string json = JsonSerializer.Serialize(person, PersonJsonContext.Default.Person);
Person p = JsonSerializer.Deserialize<Person>(json, PersonJsonContext.Default.Person);

var options = new JsonSerializerOptions
{
    NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowReadingFromString
};

using System;
using System.Text.Json;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Alice", Age = 30 };
        // オブジェクトをJSON文字列にシリアライズ
        string jsonString = JsonSerializer.Serialize(person);
        Console.WriteLine(jsonString);
    }
}

{"Name":"Alice","Age":30}

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Person
{
    [JsonPropertyName("full_name")]
    public string Name { get; set; }
    [JsonPropertyName("age_in_years")]
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        Person person = new Person { Name = "Bob", Age = 25 };
        string jsonString = JsonSerializer.Serialize(person);
        Console.WriteLine(jsonString);
    }
}

{"full_name":"Bob","age_in_years":25}

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class Temperature
{
    public int Degrees { get; set; }
    public bool IsCelsius { get; set; }
    public override string ToString() => $"{Degrees}{(IsCelsius ? "C" : "F")}";
}
public class TemperatureConverter : JsonConverter<Temperature>
{
    public override Temperature Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        string value = reader.GetString();
        int degrees = int.Parse(value.Substring(0, value.Length - 1));
        bool isCelsius = value.EndsWith("C");
        return new Temperature { Degrees = degrees, IsCelsius = isCelsius };
    }
    public override void Write(Utf8JsonWriter writer, Temperature value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value.ToString());
    }
}
public class WeatherForecast
{
    public DateTime Date { get; set; }
    [JsonConverter(typeof(TemperatureConverter))]
    public Temperature Temperature { get; set; }
}
class Program
{
    static void Main()
    {
        WeatherForecast forecast = new WeatherForecast
        {
            Date = DateTime.Now,
            Temperature = new Temperature { Degrees = 25, IsCelsius = true }
        };
        string jsonString = JsonSerializer.Serialize(forecast);
        Console.WriteLine(jsonString);
        WeatherForecast deserialized = JsonSerializer.Deserialize<WeatherForecast>(jsonString);
        Console.WriteLine($"Date: {deserialized.Date}, Temperature: {deserialized.Temperature}");
    }
}

{"Date":"2025-05-16T10:00:10.6160272+09:00","Temperature":"25C"}
Date: 2025/05/16 10:00:10, Temperature: 25C

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var person = new Person { Name = "Charlie", Age = 28 };
        string jsonRequest = JsonSerializer.Serialize(person);
        var content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
        HttpResponseMessage response = await client.PostAsync("https://example.com/api/person", content);
        response.EnsureSuccessStatusCode();
        string jsonResponse = await response.Content.ReadAsStringAsync();
        Person responsePerson = JsonSerializer.Deserialize<Person>(jsonResponse);
        Console.WriteLine($"Received: Name={responsePerson.Name}, Age={responsePerson.Age}");
    }
}

Received: Name=Charlie, Age=28

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};

var options = new JsonSerializerOptions
{
    ReferenceHandler = ReferenceHandler.Preserve
};