using System;

using System.Text.Json;

using System.Text.Json.Serialization;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

    }

}

​

public abstract class JsonConverterEx<T> : JsonConverter<T>

{

    public delegate void HandleJsonPropertyNameDelegate(Utf8JsonReader reader, string name);

​

    protected T ReadTypeFromJson(Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, Func<T> handleJsonEndObject, HandleJsonPropertyNameDelegate handleJsonPropertyName)

    {

        if (reader.TokenType != JsonTokenType.StartObject)

            throw new JsonException("Expected StartObject token");

        try 

        {

            while (reader.Read())

            {

                switch (reader.TokenType)

                {

                    case JsonTokenType.EndObject:

                        return handleJsonEndObject();

                    case JsonTokenType.PropertyName:

                        var propName = reader.GetString();

                        reader.Read();

                        handleJsonPropertyName(reader, propName);

                        break;

                }

            }

        }

        catch (JsonException e)

        {

            throw new Exception(

                $"Corrupted json", e);

        }

        catch (InvalidOperationException e)

        {

            throw new Exception(

                $"Unexpected type found", e);

        }

        throw new JsonException("Expected EndObject token");

    }

}

​

internal class ExampleConverter : JsonConverterEx<Message>

{

    public override Message Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

    {

        if (reader.TokenType != JsonTokenType.StartObject)

            throw new JsonException("Expected StartObject token");

​

        var id = Option<int>.None;

        var sentAt = Option<DateTime>.None;

        var messageText = Option<string>.None;

​

        return ReadTypeFromJson(reader, typeToConvert, options,

            () => new Message(id, sentAt, messageText),

            (reader2, propertyName) =>

            {

​

                switch (propertyName)

                {

                    case nameof(Message.Id):

                        id = Option<int>.Some(int.Parse(reader2.GetString() ?? string.Empty));

                        break;

                    case nameof(Message.SentAt):

                        sentAt = Option<DateTime>.Some(reader2.GetDateTime());

                        break;

                    case nameof(Message.MessageText):

                        messageText = Option<string>.Some(reader2.GetString()?.ToUpper());

                        break;

                }

            });

    }

    public override void Write(Utf8JsonWriter writer, Message value, JsonSerializerOptions options)

    {

        throw new NotImplementedException();

    }

}

​

public class Message

{

    public int Id { get; set; }

    public DateTime SentAt { get; set; }

    public string MessageText { get; set; }

​

    public Message(int id, DateTime sentAt, string messageText)

    {

        Id = id;

        SentAt = sentAt;

        MessageText = messageText;

    }

}

​

public struct Option<T>

{

    public static Option<T> None => default;

    public static Option<T> Some(T value) => new Option<T>(value);

​

    readonly bool isSome;

    readonly T value;

​

    Option(T value)

    {

        this.value = value;

        isSome = this.value is { };

    }

​

    public bool IsSome(out T value)

    {

        value = this.value;

        return isSome;

    }

}