Is there a way to support serializing/deserializing from and to the same properties using different property names?

[DefinitelyADev]

Now that System.Text.Json is way more mature than what it was 3-4 years ago, is there a way to support serializing/deserializing from and to the same properties using different property names?

Let's say for example, in the past with newtonsoft I would have done something like this

public class MyContractResolver : DefaultContractResolver
{
    private readonly ScopedThing _scopedThing;

    public MyContractResolver(ScopedThing scopedThing)
    {
        _scopedThing = scopedThing;
    }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {

        JsonProperty prop = base.CreateProperty(member, memberSerialization);
        MyPropertyNameAttribute? myPropertyAttribute = member.GetCustomAttribute<MyPropertyNameAttribute>();

        if (myPropertyAttribute is null)
        {
            prop.Ignored = true;
            return prop;
        }

        prop.NullValueHandling = myPropertyAttribute.IncludeNullValue ? NullValueHandling.Include : NullValueHandling.Ignore;

        switch (_scopedThing.Value)
        {
            case OtherEnum.One or OtherEnum.Two:
                {
                    prop.PropertyName = myPropertyAttribute.FirstName;
                    prop.Ignored = !myPropertyAttribute.MyCustomEnums.HasFlag(MyCustomEnum.AllowFirst);
                    return prop;
                }
            case OtherEnum.Three:
                {
                    prop.PropertyName = myPropertyAttribute.SecondName;
                    prop.Ignored = !myPropertyAttribute.MyCustomEnums.HasFlag(MyCustomEnum.AllowSecond);
                    return prop;
                }
            case OtherEnum.Four:
                {
                    prop.PropertyName = myPropertyAttribute.ThirdName;
                    prop.Ignored = !myPropertyAttribute.MyCustomEnums.HasFlag(MyCustomEnum.AllowThird);
                    return prop;
                }
            case OtherEnum.Five:
            default:
                {
                    prop.Ignored = false;
                    return prop;
                }
        }
    }
}

[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
public class MyPropertyNameAttribute : Attribute
{
    public readonly string FirstName;

    public readonly string SecondName;

    public readonly string ThirdName;
    public bool IncludeNullValue { get; init; }
    public MyCustomEnum MyCustomEnums { get; init; } = MyCustomEnum.AllowAll;

    public MyPropertyNameAttribute(string webPlatformName, string nativePlatformName)
    {
        FirstName = firstName;
        SecondName = secondName;
        ThirdName = thirdName;
    }
}


private class TestClass
{
    [MyPropertyNameAttribute("fName", "sName", "tName", MyCustomEnums = MyCustomEnum.AllowThird)]
    public bool MyProp { get; set; }
}

Is it possible to achieve similar functionality in .NET 7 and/or 8, and if so, how?

[Clockwork-Muse]

Duplicate of #87875

[Xyncgas]

To answer your question perhaps create a template struct / class to write your data to the structure before serializing.
Meanwhile consider binary serialization like google's protobuf or .NET's memory marshal that converts a struct containing only primitive types to bytes