JsonValue Structure

[SerializableAttribute]
public readonly struct JsonValue : IEquatable<JsonValue>

<SerializableAttribute>
Public Structure JsonValue
	Implements IEquatable(Of JsonValue)

[SerializableAttribute]
public value class JsonValue : IEquatable<JsonValue>

[<SealedAttribute>]
[<SerializableAttribute>]
type JsonValue =  
    struct
        interface IEquatable<JsonValue>
    end

JsonValue value = default; // = JsonValue.Undefined; = new JsonValue();

Console.WriteLine(value); // undefined
Console.WriteLine(value.Type); // Undefined
Console.WriteLine(value.IsUndefined); // True
Console.WriteLine(value == JsonValue.Undefined); // True

JsonValue value = JsonValue.Null; // = (string)null; = (bool?)null; = (JsonObject)null; etc.

Console.WriteLine(value); // null
Console.WriteLine(value.Type); // Null
Console.WriteLine(value.IsNull); // True
Console.WriteLine(value == JsonValue.Null); // True

JsonValue value = true; // = JsonValue.True; = new JsonValue(true);

Console.WriteLine(value); // true
Console.WriteLine(value.Type); // Boolean
Console.WriteLine(value.AsBoolean); // True
Console.WriteLine(value == JsonValue.True); // True
Console.WriteLine(value == true); // True

JsonValue value = 1.25; // = new JsonValue(1.25);

Console.WriteLine(value); // 1.25
Console.WriteLine(value.Type); // Number
Console.WriteLine(value.AsNumber); // 1.25

// Using a long value beyond double precision
long longValue = (1L << 53) + 1;
value = longValue; // this produces a compile-time warning about possible loss of precision
Console.WriteLine(value); // 9007199254740993
Console.WriteLine($"{value.AsNumber:R}"); // 9007199254740992 - this is what JavaScript will see
Console.WriteLine(value.AsLiteral); // 9007199254740993 - this is the actual stored value

value = longValue.ToJson(asString: false); // this is how the compile-time warning can be avoided
Console.WriteLine(value); // 9007199254740993

value = longValue.ToJson(); // this is the recommended solution to prevent losing precision
Console.WriteLine(value); // "9007199254740993" - note that ToJson produces strings for wide numeric types by default

JsonValue value = "some \"value\""; // = new JsonValue("some \"value\"");

Console.WriteLine(value); // "some \"value\""
Console.WriteLine(value.Type); // String
Console.WriteLine(value.AsString); // some "value"

JsonValue value = new JsonArray { true, 1, 2.35, JsonValue.Null, "value" };
// which is the shorthand of: new JsonValue(new JsonArray { JsonValue.True, new JsonValue(1), new JsonValue(2.35), JsonValue.Null, new JsonValue("value") });

Console.WriteLine(value); // [true,1,2.35,null,"value"]
Console.WriteLine(value.Type); // Array
Console.WriteLine(value[2]); // 2.35
Console.WriteLine(value[42]); // undefined

JsonValue value = new JsonObject
{
    ("Bool", true), // which is the shorthand of new JsonProperty("Bool", new JsonValue(true))
    // { "Bool", true }, // alternative syntax on platforms where ValueTuple types are not available
    ("Number", 1.23),
    ("String", "value"),
    ("Object", new JsonObject
    {
       ("Null", JsonValue.Null),
       ("Array", new JsonArray { 42 }),
    })
};

Console.WriteLine(value); // {"Bool":true,"Number":1.23,"String":"value","Object":{"Null":null,"Array":[42]}}
Console.WriteLine(value.Type); // Object
Console.WriteLine(value["Object"]); // {"Null":null,"Array":[42]}
Console.WriteLine(value["Object"]["Array"]); // [42]
Console.WriteLine(value["Object"]["Array"][0]); // 42
Console.WriteLine(value["UnknownProperty"]); // undefined

{
  "id": "a4a5b192-fac9-4d7c-a826-1653761fe200",
  "firstName": "John",
  "lastName": "Smith",
  "birth": "19780611",
  "active": true,
  "lastLogin": 1579955315,
  "status": "fully-trusted",
  "balances": [
    {
      "currency": "USD",
      "balance": "23462.4527"
    },
    {
      "currency": "BTC",
      "balance": "0.0567521461"
    }
  ]
}

public class Account
{
    public Guid Id { get; set; }
    public string FirstName { get; set; }
    public string? MiddleName { get; set; } // optional
    public string LastName { get; set; }
    public DateTime DateOfBirth { get; set; } // yyyyMMdd
    public bool IsActive { get; set; }
    public DateTime? LastLogin { get; set; } // Stored as Unix seconds
    public AccountStatus Status { get; set; } // Stored as lowercase values with hyphens
    public IList<AccountBalance> Balances { get; } = new Collection<AccountBalance>();
}

public enum AccountStatus { Basic, Confirmed, FullyTrusted, Disabled } // It follows the .NET naming conventions

public class AccountBalance
{
   public string Currency { get; set; }
   public decimal Balance { get; set; }
}

// in this example conversion is separated from the model as an extension method
public static JsonValue ToJson(this Account acc)
{
    var result = new JsonObject
    {
        ("id", acc.Id.ToJson()), // using ToJson(Guid)
        ("firstName", acc.FirstName), // implicit conversion from string
        ("lastName", acc.LastName), // implicit conversion from string
        ("birth", acc.DateOfBirth.ToJson("yyyyMMdd")), // ToJson(DateTime, string) with exact format
        ("active", acc.IsActive), // implicit conversion from bool
        ("lastLogin", acc.LastLogin.ToJson(JsonDateTimeFormat.UnixSeconds, asString: false)), // Unix seconds as number
        ("status", acc.Status.ToJson(JsonEnumFormat.LowerCaseWithHyphens)) // using ToJson<TEnum>()
    };

    // adding the optional middle name (it wasn't defined in the example JSON above)
    if (acc.MiddleName != null)
        result.Add("middleName", acc.MiddleName); // or: result["middleName"] = acc.MiddleName;

    // for collections and nested objects we can delegate the job to other extension methods
    if (acc.Balances.Count > 0)
        result["balances"] = new JsonArray(acc.Balances.Select(b => b.ToJson()));

    return result; // now it will be converted to JsonValue but we can also change the return type to JsonObject
}

public static JsonValue ToJson(this AccountBalance balance) => new JsonObject
{
    ("currency", balance.Currency), // implicit conversion from string
    ("balance", balance.Balance.ToJson(asString: true)), // the default of ToJson(decimal) would be a string anyway
};

// as above, this is now an extension method but could be even a constructor with JsonValue or JsonObject parameter
public static Account ToAccount(this JsonValue json)
{
    // Here we mainly use the As... methods that return null if the conversion fails
    // but you can also use the TryGet... or Get...OrDefault methods.
    var result = new Account
    {
        Id = json["id"].AsGuid() ?? throw new ArgumentException("'id' is missing or invalid"),
        FirstName = json["firstName"].AsString ?? throw new ArgumentException("'firstName' is missing or invalid"),
        MiddleName = json["middleName"].AsString, // simply returns null if missing (json["middleName"].IsUndefined)
        LastName = json["lastName"].AsString ?? throw new ArgumentException("'lastName' is missing or invalid"),
        DateOfBirth = json["birth"].AsDateTime("yyyyMMdd") ?? throw new ArgumentException("'birth' is missing or invalid"),
        IsActive = json["active"].GetBooleanOrDefault(false), // it will be false if missing (could be AsBoolean ?? false)
        LastLogin = json["lastLogin"].AsDateTime(JsonDateTimeFormat.UnixSeconds), // will be null if missing or invalid
        Status = json["status"].GetEnumOrDefault(true, AccountStatus.Disabled) // true to ignore case and hyphens
    };

    var balances = json["balances"];

    // a missing 'balances' is accepted
    if (balances.IsUndefined) // or: balances == JsonValue.Undefined
        return result;

    // but if exists, must be an array
    if (balances.Type != JsonValueType.Array) // or: balances.AsArray is not JsonArray
        throw new ArgumentException("'balances' is invalid");

    foreach (JsonValue balance in balances.AsArray)
        result.Balances.Add(balance.ToBalance());

    return result;
}

public static AccountBalance ToBalance(this JsonValue json) => new AccountBalance
{
    Currency = json["currency"].AsString ?? throw new ArgumentException("'currency' is missing or invalid"),
    Balance = json["balance"].AsDecimal() ?? 0m // or AsDecimal(JsonValueType.String) to disallow JSON numbers
};