Binding JSON object inside of array in .NET

It looks as though the JSON is supposed to represent matches in some overall string, in this case a match of the string "judgement" in In (consolidated) enforcement actions for failure to answer subpoena, appeal from judgement for defendants. Thus, your data model is going to need to be able to reconstruct the entire string, as well as pick out the matched portion.

Assuming the JSON cannot be changed, I'd suggest a data model like the following:

public class RootObject
{
    [JsonProperty(PropertyName = "snippets")]
    public MarkLogicSnippetsModel Snippets { get; set; }
}

public class MarkLogicSnippetsModel
{
    [JsonProperty(PropertyName = "match")]
    public IEnumerable<MarkLogicMatchModel> Matches { get; set; }
}

public class MarkLogicMatchModel
{
    [JsonProperty(PropertyName = "value")]
    public List<MarkLogicMatchEntry> Values { get; set; }
}

public enum MatchType
{
    Normal,
    Highlight,
}

[JsonConverter(typeof(MarkLogicMatchEntryConverter))]
public class MarkLogicMatchEntry
{
    public MatchType MatchType { get; set; }

    public string Value { get; set; }
}

Using the following converter:

class MarkLogicMatchEntryConverter : JsonConverter
{
    JsonSerializer GetEnumSerializer()
    {
        return JsonSerializer.CreateDefault(new JsonSerializerSettings { Converters = new[] { new StringEnumConverter { CamelCaseText = true } } });
    }

    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(MarkLogicMatchEntry);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;
        else if (reader.TokenType == JsonToken.String)
        {
            return new MarkLogicMatchEntry { MatchType = MatchType.Normal, Value = reader.Value.ToString() };
        }
        else
        {
            var obj = JObject.Load(reader);
            var property = obj.Properties().FirstOrDefault();
            var type = ((JValue)property.Name).ToObject<MatchType>(GetEnumSerializer());
            var value = (string)property.Value.SelectToken("value");

            return new MarkLogicMatchEntry { MatchType = type, Value = value };
        }
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var match = (MarkLogicMatchEntry)value;
        if (match.MatchType == MatchType.Normal)
        {
            writer.WriteValue(match.Value);
        }
        else
        {
            var propertyName = (string)JToken.FromObject(match.MatchType, GetEnumSerializer());
            var obj = new JObject(new JProperty(propertyName, new JObject(new JProperty("value", match.Value))));
            obj.WriteTo(writer);
        }
    }
}

Here each section of the searched string is represented by a MarkLogicMatchEntry class. Normal, unmatched substrings are represented with MatchType = MatchType.Normal. Matched substrings are represented with MatchType = MatchType.Highlight. In theory other match types such as MatchType.Underline could be added if required.

The JSON itself is pretty terrible, this is the best code model I could get to work with it, you will have to use the dynamic keyword to actually use the value data..... the way the top level 'value' is being used is not really cleanly parsable. As it stands it is an array that has 3 items, but two of them are strings and one of them is an object 'highlight'

public class Match
{
    public List<object> value { get; set; }
}

public class Snippets
{
    public List<Match> match { get; set; }
}

public class RootObject
{
    public Snippets snippets { get; set; }
}

The JSON you're sending is JavaScript compatible because in JS you can have different type of objects, string, numbers, etc. in an array.

But you declared the values array to be an IEnumerable<string>, that means value in the JSON you send must be an array of strings, you can't put an object because C# is has strongly typed arrays. What you're basically trying to do is this:

List<string> strings = new List<string>();
strings.Add("123");
strings.Add(new { foo: "foo" });

That won't work.

The most simple solution is to change the JSON layout to be valid for C#. You could use this:

"match": [{
    "value": {
        "text": "In (consolidated) enforcement actions for failure to answer subpoena, appeal from {0}  for defendants.",
        "markup": [{
            "type": "highlight",
            "value" : "judgement"
        }]

    }
}]

Add a class for Markup

public class Markup
{
    [JsonProperty(PropertyName = "type")]
    public string Type { get; set; }
    [JsonProperty(PropertyName = "value")]
    public string Value {get; set; }
}

Then another one for Value

public class Value
{
    [JsonProperty(PropertyName = "text")]
    public string Text{ get; set; }
    [JsonProperty(PropertyName = "markup")]
    public IEnumerable<Markup> Markup {get; set; }
}

Then change MarkLogicMatchModel

public class MarkLogicMatchModel
{
    [JsonProperty(PropertyName = "value")]
    public IEnumerable<Value> Values { get; set; }
}

Later you could use String.Format to append the parsed markup to the text. This will work if the input text does not have { or }, and if it comes from a component you control, of course.

If that doesn't work, you'll have to go use dynamic as Paul suggested, no other way. More on that here

Current .NET 6 ConfigurationBuilder offers an efficient Bind method in C#.

json file

{
  "Position": {
    "Title": "Editor",
    "Name": "Joe Smith",
    "Devs": [ "Ford", "BMW", "Fiat" ],
    "Param": {
      "Port": "1234"
    }
  }
}

call of Binding and config

_con = new ConfigurationBuilder()
    .AddJsonFile("DeviceMapper.config.json", optional: false, reloadOnChange: false)
    .Build();

var positionOptions = new PositionOptions();
_con.GetSection(PositionOptions.Position).Bind(positionOptions);
Debug.WriteLine(positionOptions.Name);

models including nested class:

public class PositionOptions
{
    public class PositionParameter
    {
        public string Port { get; set; } = String.Empty;
        public string Address { get; set; } = String.Empty;
    }

    public const string Position = "Position";

    public string Title { get; set; } = String.Empty;
    public string Name { get; set; } = String.Empty;

    public List<string>? Devs { get; set; }

    public PositionParameter? Param { get; set; }
}

example project and code is on github https://github.com/flowxcode/sharp-conf-binder