Frozen Collections

[TonyValenti]

1. Can STJ deserialize into these?
2. Is there a FrozenList?

[huoyaoyuan]

Can STJ deserialize into these?

We can add converters for them in the future, of course. You can also write yours.

Is there a FrozenList?

It's just an ImmutableArray. The frozen collections are optimized for reading.

[TonyValenti]

Hi @stephentoub -
When we get Json from APIs, we generally get something that looks like this:

{
  "Data": [
    {
      "Name": "John Smith",
      "Custom_Values": {
        "14": {
          "Definition": {
            "Id": 46
          },
          "Value": "2023-17-16",
          "Id": 7,
          "Created_At": "2023-08-05T18:15:20.5843392+00:00",
          "Updated_At": "2023-08-05T18:15:20.5843394+00:00"
        },
        "26": {
          "Definition": {
            "Id": 37
          },
          "Value": "Motion to Quash",
          "Id": 9,
          "Created_At": "2023-08-05T18:15:20.5843659+00:00",
          "Updated_At": "2023-08-05T18:15:20.5843659+00:00"
        }
      },
      "Id": 1,
      "Created_At": "2023-08-05T18:15:20.5838881+00:00",
      "Updated_At": "2023-08-05T18:15:20.5839574+00:00"
    },
    {
      "Name": "Jane Doe",
      "Custom_Values": {
        "14": {
          "Definition": {
            "Id": 46
          },
          "Value": "2001-02-02",
          "Id": 79,
          "Created_At": "2023-08-05T18:15:20.5947717+00:00",
          "Updated_At": "2023-08-05T18:15:20.5947718+00:00"
        },
        "27": {
          "Definition": {
            "Id": 456
          },
          "Value": "Wife",
          "Id": 123,
          "Created_At": "2023-08-05T18:15:20.5947739+00:00",
          "Updated_At": "2023-08-05T18:15:20.5947739+00:00"
        }
      },
      "Id": 1,
      "Created_At": "2023-08-05T18:15:20.5947695+00:00",
      "Updated_At": "2023-08-05T18:15:20.5947698+00:00"
    }
  ],
  "Meta": {}
}

We will have classes like this:

    public record ResponseJson { 
        public MetaJson? Meta { get; init; }
    }

    public record ResponseJson<T> : ResponseJson { 
        public T? Data { get; init; }
    }

    public record MetaJson { 
        //...
    }

    public record EntityJson { 
        public long Id { get; init; }
        public DateTimeOffset Created_At { get; init; }
        public DateTimeOffset Updated_At { get; init; }
    }

    public record PersonJson : EntityJson { 
        public string? Name { get; init; }
        public ImmutableDictionary<long, CustomValueJson>? Custom_Values { get; init; } // <--- This is a high access property
    }

    public record CustomValueJson : EntityJson { 
        public IdReferenceJson<CustomDefinitionJson>? Definition { get; init; }
        public string? Value { get; init; }
    }

    public record IdReferenceJson { 
        public long Id { get; init; }
    }

    public record IdReferenceJson<T> : IdReferenceJson { 
        
    }

    public record CustomDefinitionJson : EntityJson { 
        //...
    }

And then we'll deserialize with something like this:

var R = System.Text.Json.JsonSerializer.Deserialize<ResponseJson<PersonJson>>(Content);

And we'll cache the individual elements in R.Data for the entire duration of the application. During execution we will make extensive access to the values in the Custom_Values member. It is an ImmutableDictionary which is great because it enforces that the values cannot change. However, given the performance benefits of frozen collections (and the fact that we never change or mutate it), I would like to leverage FrozenDictionary instead.

The above example is concise, but during runtime it is not uncommon for use to have 200k PersonJson instances each which has 50-200 entries in Custom_Values. It seems like FrozenDictionary would immediately give us a speed boost simply by changing the dictionary type.

[LeaFrock]

You can change the type of Custom_Values to JsonElement，then convert it to frozen collection with EnumerateArray() after deserialization.

[TonyValenti]

@LeaFrock If I understand you correctly, then I have to have two versions of PersonJson - one where Custom_Values is a JsonElement and another where it is a FrozenDictionary and then convert between the two. Am I correct on that?

[LeaFrock]

You don't need to do so. One easy way I think of is something like the following,

public record PersonJson : EntityJson { 
        public string? Name { get; init; }
        public JsonElement Custom_Values { get; init; } // <--- This is a high access property

        private FrozenDictionary<long, CustomValueJson> _dict;

        public FrozenDictionary<long, CustomValueJson> GetFrozenCustomValues()
        {
              if(_dict is null) // In cocurrent environment, use double-check lock or use Lazy<T>
              {
                    // initialize the frozen dict
              }
              return _dict;
        }
        
        // Or use an extra property with [JsonIgnore]
       [JsonIgnore]
       public FrozenDictionary<long, CustomValueJson> Custom_Values_Dict
       {
              get 
              {
                   // initialize and return the frozen dict
              }
       }
    }

It wouldn‘t require too much work for refactor.

[TonyValenti]

@LeaFrock - That would never pass code review.

I guess the question is whether we would write the deserializer ourselves or if it could be provided as part of STJ. I hope that @stephentoub or another member will add it into STJ because (1) I imagine that caching deserialized Json is common and (2) I imagine the deserializer could share a lot of code with the ImmutableDictionary deserializer.