using System;

using System.Reflection;

using System.Linq;

using System.Collections.Generic;

using System.Text.Json;

using System.Text.Json.Serialization;

public class Program

{

    public static void Main()

    {

        var p = new Project

        {

          Name = "MyProject",

          Environments = {

            new Environment {

              Name = "dev",

              Region = "us1",

              Settings = {

                OverrideOnFetch = false

              }

            },

            new Environment {

              Name = "prod",

              Region = "us1",

              Settings = {

                 OverrideOnFetch = false

              }

            }

          }

        };

​

        Console.WriteLine(JsonSerializer.Serialize(p, new JsonSerializerOptions{ WriteIndented = true}));

    }

}

​

public class Project

{

   public string Name {get;set;}

​

    [JsonConverter(typeof(PropertyToObjectListConverter<Environment>))]

    public List<Environment> Environments {get;set;} = new();

}

public class Environment

{

    [JsonIgnore]

   public string Name {get;set;}

   public string Region {get;set;}

   public Settings Settings {get;set;} = new();

}

public class Settings

{

   public bool OverrideOnFetch {get;set;}

}

​

[AttributeUsage(AttributeTargets.Property)]

public class JsonPropertyToObjectAttribute : Attribute

{

}

​

public class PropertyToObjectListConverter<T> : JsonConverter<ICollection<T>>

{

    static PropertyInfo _nameProp =

        typeof(T).GetProperties().FirstOrDefault(p => p.GetCustomAttributes(typeof(JsonPropertyToObjectAttribute)).Any())

        ?? typeof(T).GetProperty("Name");

​

    static Func<T, string> _getter = _nameProp?.GetMethod?.CreateDelegate<Func<T, string>>() ?? throw new Exception("No getter available");

    static Action<T, string> _setter = _nameProp?.SetMethod?.CreateDelegate<Action<T, string>>() ?? throw new Exception("No setter available");

​

    public override bool CanConvert(Type typeToConvert) =>

        typeof(ICollection<T>).IsAssignableFrom(typeToConvert);

​

    public override ICollection<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

    {

        var dict = JsonSerializer.Deserialize<Dictionary<string, T>>(ref reader, options);

        var coll = (ICollection<T>) Activator.CreateInstance(typeToConvert);

        foreach (var kvp in dict)

        {

            var value = kvp.Value;

            _setter(value, kvp.Key);

            coll.Add(value);

        }

        return coll;

    }

    public override void Write(Utf8JsonWriter writer, ICollection<T> value, JsonSerializerOptions options)

    {

        var dict = value.ToDictionary(_getter);

        JsonSerializer.Serialize(writer, dict, options);

    }

}