How to convert an object to JSON in C#

using System.Text.Json;

var user = new User("Ada Lovelace", "[email protected]", 36, ["admin", "math"]);

// One call: object in, JSON string out
string json = JsonSerializer.Serialize(user);
Console.WriteLine(json);

// Pretty-print with WriteIndented
var pretty = new JsonSerializerOptions { WriteIndented = true };
Console.WriteLine(JsonSerializer.Serialize(user, pretty));

// JsonSerializerOptions.Web (.NET 9+): camelCase names, like ASP.NET Core
Console.WriteLine(JsonSerializer.Serialize(user, JsonSerializerOptions.Web));

// Anonymous types, lists and dictionaries work the same way
Console.WriteLine(JsonSerializer.Serialize(new { Id = 7, Tags = new[] { "a", "b" } }));
Console.WriteLine(JsonSerializer.Serialize(new List<int> { 1, 2, 3 }));
Console.WriteLine(JsonSerializer.Serialize(new Dictionary<string, double> { ["pi"] = 3.14, ["e"] = 2.72 }));

// UTF-8 bytes directly, for a file or an HTTP body
byte[] utf8 = JsonSerializer.SerializeToUtf8Bytes(user);
Console.WriteLine($"{utf8.Length} bytes");

record User(string Name, string Email, int Age, List<string> Roles);

using System.Text.Json;
using System.Text.Json.Serialization;

var product = new Product { Id = 42, DisplayName = "USB-C cable", PriceCents = 1299, InternalNote = "reorder soon" };

// Attributes on the type decide names, order and what is left out
Console.WriteLine(JsonSerializer.Serialize(product));

// A naming policy renames every property that has no [JsonPropertyName]
var snake = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower };
Console.WriteLine(JsonSerializer.Serialize(product, snake));

// Public fields are skipped unless you opt in
var point = new Point { X = 3, Y = 4 };
Console.WriteLine(JsonSerializer.Serialize(point));
Console.WriteLine(JsonSerializer.Serialize(point, new JsonSerializerOptions { IncludeFields = true }));

class Product
{
    public int PriceCents { get; set; }

    [JsonPropertyName("name")]
    public string DisplayName { get; set; } = "";

    [JsonPropertyOrder(-1)]
    public int Id { get; set; }

    [JsonIgnore]
    public string InternalNote { get; set; } = "";

    // Non-public members are skipped, unless marked [JsonInclude]
    [JsonInclude]
    internal string Sku { get; set; } = "CBL-USB-C";

    private string supplier = "Acme";
}

class Point
{
    public int X;
    public int Y;
}

using System.Text.Json;
using System.Text.Json.Serialization;

var order = new Order(1001, Status.Shipped, Priority.High, Access.Read | Access.Write);

// By default an enum is written as its number
Console.WriteLine(JsonSerializer.Serialize(order));

// Every enum as a string: add the converter to the options
var options = new JsonSerializerOptions();
options.Converters.Add(new JsonStringEnumConverter());
Console.WriteLine(JsonSerializer.Serialize(order, options));

// With a naming policy, and with numbers refused when reading back
var camel = new JsonSerializerOptions();
camel.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase, allowIntegerValues: false));
Console.WriteLine(JsonSerializer.Serialize(order, camel));

try
{
    JsonSerializer.Deserialize<Order>("""{"Id":1,"Status":2,"Priority":"high-priority","Access":"Read"}""", camel);
}
catch (JsonException e)
{
    Console.WriteLine($"JsonException: {e.Message}");
}

record Order(int Id, Status Status, Priority Priority, Access Access);

enum Status { Pending, Paid, Shipped }

// One enum always as a string, whatever the options say
[JsonConverter(typeof(JsonStringEnumConverter<Priority>))]
enum Priority
{
    Low,
    [JsonStringEnumMemberName("high-priority")]   // .NET 9+
    High,
}

[Flags]
enum Access { None = 0, Read = 1, Write = 2, Delete = 4 }

using System.Text.Json;
using System.Text.Json.Serialization;

var contact = new Contact { Name = "Grace", Email = null, Phone = null, Visits = 0, Score = null };

// Default: null properties are written as null
Console.WriteLine(JsonSerializer.Serialize(contact));

// Skip every null property
var noNulls = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull };
Console.WriteLine(JsonSerializer.Serialize(contact, noNulls));

// Skip nulls AND default values: 0, false, default(DateTime)...
var noDefaults = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault };
Console.WriteLine(JsonSerializer.Serialize(contact, noDefaults));

// Per property, with no options at all: see Phone in the class below
contact.Phone = "555-0100";
Console.WriteLine(JsonSerializer.Serialize(contact));

class Contact
{
    public string Name { get; set; } = "";
    public string? Email { get; set; }

    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    public string? Phone { get; set; }

    public int Visits { get; set; }
    public int? Score { get; set; }

    // Opts out of the global setting: always written
    [JsonIgnore(Condition = JsonIgnoreCondition.Never)]
    public string? Notes { get; set; }
}

using System.Text.Json;
using System.Text.Json.Serialization;

var team = new Team { Name = "Compilers" };
team.Members.Add(new Member { Name = "Linus", Team = team });
team.Members.Add(new Member { Name = "Barbara", Team = team });

// Team -> Member -> Team -> ... has no end, so the default throws
try
{
    JsonSerializer.Serialize(team);
}
catch (JsonException e)
{
    Console.WriteLine($"JsonException: {e.Message[..e.Message.IndexOf(" Path:")]}");
}

// IgnoreCycles (.NET 6+): a reference back to an object already being written becomes null
var ignore = new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.IgnoreCycles };
Console.WriteLine(JsonSerializer.Serialize(team, ignore));

// Preserve: $id / $ref metadata keeps the graph, but only .NET readers understand it
var preserve = new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.Preserve };
Console.WriteLine(JsonSerializer.Serialize(team, preserve));

// Usually best: serialize a shape without the back-reference
var dto = new { team.Name, Members = team.Members.Select(m => m.Name) };
Console.WriteLine(JsonSerializer.Serialize(dto));

class Team
{
    public string Name { get; set; } = "";
    public List<Member> Members { get; } = [];
}

class Member
{
    public string Name { get; set; } = "";
    public Team? Team { get; set; }   // back-reference: [JsonIgnore] here also breaks the loop
}

using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Unicode;

var note = new { Title = "Café <b>menu</b>", Price = "5 €", Quote = "it's \"fine\" & cheap" };

// Default: non-ASCII and HTML-sensitive characters are \u-escaped
Console.WriteLine(JsonSerializer.Serialize(note));

// Keep all Unicode letters and symbols as they are
var unicode = new JsonSerializerOptions { Encoder = JavaScriptEncoder.Create(UnicodeRanges.All) };
Console.WriteLine(JsonSerializer.Serialize(note, unicode));

// Also stop escaping < > & ' (never embed this output in HTML unencoded)
var relaxed = new JsonSerializerOptions { Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping };
Console.WriteLine(JsonSerializer.Serialize(note, relaxed));

// Either way the parsed value is identical
var back = JsonDocument.Parse(JsonSerializer.Serialize(note)).RootElement.GetProperty("Title").GetString();
Console.WriteLine(back);