How to reset an Utf8JsonReader to its starting position?

Question

I know from the docs that this is technically not possible (Utf8JsonReader is forward-only with no caching mechanism), but I want to know if I can achieve something equivalent in behaviour.

Below is my use case and the problem I have with Utf8JsonReader's incapability of resetting to its start position.

---

I have some classes and subclasses that I want to (de-)serialize to JSON using System.Text.Json. Serialization works perfectly without any custom JsonConverter needed; I just need to add a JsonStringEnumConverter.

public class Foo
{
    public Foo(BarBase bar) { Bar = bar; }

    public BarBase Bar { get; init; }
}

public class BarBase
{
    public BarBase(string text, BarType type) { Text = text; Type = type; }

    public string Text { get; init; }
    public BarType Type { get; init; }
}

public class BarSub1 : BarBase
{
    public BarSub1(string text) : base(text, BarType.sub1) {}
}

public class BarSub2 : BarBase
{
    public BarSub2(string text) : base(text, BarType.sub2) {}
}

public enum BarType { base, sub1, sub2 }

Here is the serialization:

var foo = new Foo(new BarSub1("bar"));
var json = JsonSerializer.Serialize(foo,
    new JsonSerializerOptions { Converters = { new JsonStringEnumConverter() } };
// json is { "Bar": { "Text": "bar", "Type": "sub1" } }

Deserialization does not work out of the box (it does not throw errors but it always deserializes my Bar objects to BarBase, which I don't want); for that I need a JsonConverter according to the answers here and here. So I tried writing one, but can't get it working. The problem is: In order to determine the type I want to deserialize, I need to read a bit of the Json (until I get the Type property). So the Utf8JsonReader is not at its starting position any more. But since the Type property is part of the class (and part of what the JsonSerializer handles), I cannot start deserializting with the JsonSerializer.Deserialize method after I have already ran over the Type property. I would need to call JsonSerializer.Deserialize before any Read()ing was done.

public class BarConverter : JsonConverter<BarBase>
{
    public override BarBase Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        Type BarTypeToType(BarType t)
        {
            switch (t)
            {
                case base: return typeof(BarBase);
                case sub1: return typeof(BarSub1);
                case sub2: return typeof(BarSub2);
                default: throw new ArgumentException();
            }
        }
    
        if (reader.TokenType != JsonTokenType.StartObject)
            throw new JsonException("missing start object");

        bool discriminatorFound = false;
        while (reader.Read())
        {
            if (reader.TokenType != JsonTokenType.PropertyName)
                continue;
            if (reader.GetString() != "Type")
                continue;
            discriminatorFound = true;
            break;
        }

        if (!discriminatorFound)
            throw new JsonException($"type discriminator property not found");

        if (!reader.Read() || reader.TokenType != JsonTokenType.String)
            throw new JsonException("type discriminator value does not exist or is not a string");

        var typeString = reader.GetString();
        if (!Enum.TryParse(typeString, out BarType enumValue))
            throw new JsonException($"value {typeString} is not an element of {nameof(BarType)}");

        // PROBLEM: This doesn't work, since we are not at the start position any more!
        BarBase instance = (BarBase)JsonSerializer.Deserialize(ref reader, BarTypeToType(enumValue), options)!;

        if (!reader.Read() || reader.TokenType != JsonTokenType.EndObject)
            throw new JsonException("missing end object");

        return instance;
    }

    public override void Write(Utf8JsonWriter writer, BaseType value, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }
}

Can someone help?