Is there an XML or JSON Serializer that knows which Constructor to use to Populate an Immutable Object and also Serialize IEnumerable<> Properties?

Question

Supposing I have this immutable struct:

public struct LogGroup
{
    public Log<LowResolutionLogData> LowResolutionLog { get; }

    public IEnumerable<Log<MediumResolutionLogData>> MediumResolutionLogs { get; }

    public IEnumerable<Log<HighResolutionLogData>> HighResolutionLogs { get; }

    public LogGroup
    (
        Log<LowResolutionLogData> lowResolutionLog,
        IEnumerable<Log<MediumResolutionLogData>> mediumResolutionLogs,
        IEnumerable<Log<HighResolutionLogData>> highResolutionLogs
    )
    {
        LowResolutionLog = lowResolutionLog;
        MediumResolutionLogs = mediumResolutionLogs;
        HighResolutionLogs = highResolutionLogs;
    }
}

How do I serialize it without having to making the IEnumerable<> properties some concrete type (e.g. an Array or List)?

How do I deserialize into it without having to make the properties all settable (I want it to call the assignment constructor I've created)?

The complex types on the object may also have their own complex types and IEnumerable<>s as immutable properties. Log<> is a class whilst the types it takes are all structs so deserialization using assignment constructors needs to work for both. One of these types has a large number of properties so I want to avoid boilerplate code and have the serialization/deserialization handled dynamically if possible.

Answer 1

A big thanks to JSteward for pointing me in the right direction on this. All I needed was this to serialize my LogGroup and write it to a file.

using (var streamWriter = File.CreateText(filePath))
    new JsonSerializer().Serialize(streamWriter, myLogGroup);

and this to read it from a file and turn it back into a LogGroup:

using (var streamReader = File.OpenText(filePath))
    var myLogGroup = (LogGroup)new JsonSerializer().Deserialize(streamReader, typeof(LogGroup));

I also had to mark the assignment constructor for each struct with [JsonConstructor] in order for Deserialize to use it (otherwise the properties were receiving their default values).

All type abstraction was handled for serialization.

As a side note, I used a .tt design-time template to create each of my objects to reduce the maintenance overhead of having an assignment constructor (I generate the properties, constructor parameters and property assignments all from one source).