Is there a way to replace a converter for a type in a source generated JsonSerializerContext?

[paulomorgado]

Imagine I have this DTO:

public class Message
{
    public Guid Id { get; set; }
    ReadOnlySequence<byte> Data { get; set; }
    // ...
}

And this source generated serializer context:

[JsonSerializable(typeof(Message))]
public partial class MessageJsonSerializerContext: JsonSerializerContext
{
}

The source generator tries to generate code to serialize ReadOnlySequence<byte> which it can't.

I tried:

public class Message
{
    public Guid Id { get; set; }
    [JsonConverter(typeof(ReadOnlySequenceOfByteConverterConverter))]
    ReadOnlySequence<byte> Data { get; set; }
    // ...
}

And the source generator correctly generates:

JsonPropertyInfoValues<ReadOnlySequence<byte>> info1 = new JsonPropertyInfoValues<ReadOnlySequence<byte>>()
{
    IsProperty = true,
    IsPublic = true,
    IsVirtual = false,
    DeclaringType = typeof(Message),
    PropertyTypeInfo = jsonContext.ReadOnlySequenceByte,
    Converter = new ReadOnlySequenceOfByteConverterConverter(),
    Getter = static (obj) => ((Message)obj).Data,
    Setter = static (obj, value) => ((Message)obj).Data = value!,
    IgnoreCondition = JsonIgnoreCondition.Never,
    HasJsonInclude = false,
    IsExtensionData = false,
    NumberHandling = default,
    PropertyName = "Data",
    JsonPropertyName = "data"
};

But still generates code to serialize ReadOnlySequence<byte>, ReadOnlyMemory<byte> and ReadOnlySpan<byte>.

[hez2010]

You can put [JsonIgnore] on Data.

[paulomorgado]

How will that help serialize that property? Can you show some example?

[hez2010]

How about creating a wrapper property for this where DataForSerailization is only used for json serialization?

public class Message
{
    public Guid Id { get; set; }
    [JsonIgnore]
    public ReadOnlySpan<byte> Data { get; set; }
    [JsonPropertyName(nameof(Data))]
    public byte[] DataForSerailization
    {
        get => Data.ToArray();
        set => Data = value;
    }
}

[paulomorgado]

The reason I'm trying to use a ReadOnlySequence<byte> is because that is the source I have and I don't want to allocate a large byte[] for a partitioned source I already have materialized.

I just don't want to hand serialize the type (there are more properties than the ones shown), but I can write a JsonConverter<ReadOnlySequence<byte>>. I just would like the source generator to fully honor the given converter and not generate anything else.

[paulomorgado]

By the way, in .NET 8.0 the source generator correctly handles ReadOnlyMemory<byte> and Memory<byte> . But still ignores that a convert is already provided for the type.

[paulomorgado]

In .NET 8.0 this is possible:

public class Dto
{
    public ReadOnlySequenceOfByteWrapper Data { get; set; }
}

[JsonConverter(typeof(ReadOnlySequenceOfByteWrapperJsonConverter))]
public readonly struct ReadOnlySequenceOfByteWrapper(ReadOnlySequence<byte> data)
{
    [JsonIgnore]
    public ReadOnlySequence<byte> Data { get; } = data;
}

[JsonSerializable(typeof(Dto))]
public partial class Class1JsonSerializationContext : JsonSerializerContext
{
}

public class ReadOnlySequenceOfByteWrapperJsonConverter : JsonConverter<ReadOnlySequenceOfByteWrapper>
{
    public override ReadOnlySequenceOfByteWrapper Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }

    public override void Write(Utf8JsonWriter writer, ReadOnlySequenceOfByteWrapper value, JsonSerializerOptions options)
    {
        var quote = new ReadOnlyMemory<byte>([(byte)'"']);

        var first = new ReadOnlySequenceSegmentOfByte(quote);
        var last = first;
        var length = 2L;

        var buffers = new List<byte[]>();

        ReadOnlySpan<byte> pending = default;

        foreach (var segment in value.Data)
        {
            var span = segment.Span;

            while (span.Length > 0)
            {
                var buffer = ArrayPool<byte>.Shared.Rent(3 + span.Length / 4 * 3);

                var result = Base64.EncodeToUtf8(span, buffer, out var bytesConsumed, out var bytesWritten, false);

                if (bytesWritten == 0)
                {
                    pending = span;
                    span = default;
                    ArrayPool<byte>.Shared.Return(buffer);
                    break;
                }

                buffers.Add(buffer);

                last = last.Append(buffer.AsMemory(0, bytesWritten));

                length += bytesWritten;

                span = span[bytesConsumed..];
            }
        }

        {
            var buffer = ArrayPool<byte>.Shared.Rent(4);
            buffers.Add(buffer);

            Base64.EncodeToUtf8(pending, buffer, out var bytesConsumed, out var bytesWritten, true);

            last = last.Append(buffer.AsMemory(0, bytesWritten));

                length += bytesWritten;
        }

        last = last.Append(quote);

        var data = new ReadOnlySequence<byte>(first, 0, last, (int)(length - last.RunningIndex));

        writer.WriteRawValue(data, true);

        foreach (var buffer in buffers)
        {
            ArrayPool<byte>.Shared.Return(buffer);
        }
    }

    private sealed class ReadOnlySequenceSegmentOfByte : ReadOnlySequenceSegment<byte>
    {
        public ReadOnlySequenceSegmentOfByte(ReadOnlyMemory<byte> memory)
        {
            Memory = memory;
        }

        public ReadOnlySequenceSegmentOfByte Append(ReadOnlyMemory<byte> memory)
        {
            var nextSegment = new ReadOnlySequenceSegmentOfByte(memory) { RunningIndex = RunningIndex + Memory.Length };
            Next = nextSegment;
            return nextSegment;
        }
    }
}

But this defeats my entire purpose, because I wanted to directly write the contents to avoid allocations, which is not possible with Utf8JsonWriter.