Parsing a Json object that contains a field with two distinct types, one of which is recursive

Question

Parsing a Json object that contains a field with two distinct types, one of which is recursive

In my project, I have a TypeScript component that retrieves JSON data, and I need to parse this JSON in C# to work with the objects. However, due to the presence of:

multiple type fields
recursion

it's becoming challenging to understand how the deserialization process should be implemented. I am aware that I need to use a JsonConverter for handling multiple type fields, but I'm unsure how to handle recursion in conjunction with multiple type fields.

Below is the TypeScript code responsible for generating the JSON:

export interface FilterDescriptor {

  field ? : string | Function;

  operator: string | Function;

  value ? : any;

  ignoreCase ? : boolean;
}

export interface CompositeFilterDescriptor {
  logic: 'or' | 'and';

  filters: Array < FilterDescriptor | CompositeFilterDescriptor > ;
}

export declare
const isCompositeFilterDescriptor: (source: FilterDescriptor | CompositeFilterDescriptor) => source is CompositeFilterDescriptor;

Here are some examples of the generated JSON:

With recursion:

{
"logic": "and",
"filters": [
  {
    "field": "type.group",
    "logic": "and",
    "filters": [
      {
        "field": "type.group",
        "operator": "neq",
        "value": 2
      },
      {
        "field": "type.group",
        "operator": "neq",
        "value": 5
      }
    ]
  }
]}

Without recursion:

{
"logic": "and",
"filters": [
  {
    "field": "type.group",
    "operator": "eq",
    "value": 2
  }
]}

This JSON is generated using Kendo UI for Angular from Telerik's "CompositeFilterDescriptor."

Thank you.

c#json typescript telerik deserialization

Answer 1

Answer №1

The challenge here lies in the fact that C# lacks an equivalent feature to the 'discriminated union' concept (or that's what I believe it's referred to as ;-))

When it comes to achieving polymorphism in C#, your options are limited to interfaces and inheritance.

For this particular scenario, you require two types (FilterDescriptor and CompositeFilterDescriptor) and the use of polymorphism is necessary because CompositeFilterDescriptor contains an array that can house either of these types. In C#, you would typically utilize an interface or base class to represent this:

interface IFilterDescriptor { }

class FilterDescriptor : IFilterDescriptor
{
    // ... (fields of FilterDescriptor)
}

class CompositeFilterDescriptor : IFilterDescriptor
{
    public string @logic { get; set; }
    public IFilterDescriptor[] filters { get; set; }
}

Moreover, default deserialization with Json.NET cannot be used in this case, as it requires type information for polymorphic deserialization. Alternatively, you can create a custom converter where you can analyze specific fields to determine how to deserialize an object:

public class FilterDescriptorConverter : JsonConverter
{
    public override bool CanConvert(Type objectType) => typeof(IFilterDescriptor).IsAssignableFrom(objectType);

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JObject o = JObject.Load(reader);

        // if the 'logic' field is present, it's a CompositeFilter
        var item = o["logic"] != null 
            ? (IFilterDescriptor)new CompositeFilterDescriptor() 
            : (IFilterDescriptor)new FilterDescriptor();
        serializer.Populate(o.CreateReader(), item);
        return item;
    }

    public override bool CanWrite => false;
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => throw new NotImplementedException();
}

Usage example:

var result = JsonConvert.DeserializeObject<IFilterDescriptor>(json, 
          new FilterDescriptorConverter());

Answer 2

The challenge here lies in the fact that C# lacks an equivalent feature to the 'discriminated union' concept (or that's what I believe it's referred to as ;-))

When it comes to achieving polymorphism in C#, your options are limited to interfaces and inheritance.

For this particular scenario, you require two types (FilterDescriptor and CompositeFilterDescriptor) and the use of polymorphism is necessary because CompositeFilterDescriptor contains an array that can house either of these types. In C#, you would typically utilize an interface or base class to represent this:

interface IFilterDescriptor { }

class FilterDescriptor : IFilterDescriptor
{
    // ... (fields of FilterDescriptor)
}

class CompositeFilterDescriptor : IFilterDescriptor
{
    public string @logic { get; set; }
    public IFilterDescriptor[] filters { get; set; }
}

Moreover, default deserialization with Json.NET cannot be used in this case, as it requires type information for polymorphic deserialization. Alternatively, you can create a custom converter where you can analyze specific fields to determine how to deserialize an object:

public class FilterDescriptorConverter : JsonConverter
{
    public override bool CanConvert(Type objectType) => typeof(IFilterDescriptor).IsAssignableFrom(objectType);

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JObject o = JObject.Load(reader);

        // if the 'logic' field is present, it's a CompositeFilter
        var item = o["logic"] != null 
            ? (IFilterDescriptor)new CompositeFilterDescriptor() 
            : (IFilterDescriptor)new FilterDescriptor();
        serializer.Populate(o.CreateReader(), item);
        return item;
    }

    public override bool CanWrite => false;
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => throw new NotImplementedException();
}

Usage example:

var result = JsonConvert.DeserializeObject<IFilterDescriptor>(json, 
          new FilterDescriptorConverter());

Parsing a Json object that contains a field with two distinct types, one of which is recursive

Answer №1

Similar questions

The procedure or process has not been executed

Instructions for programmatically deleting a file from an SFTP server using SharpSSH

Using JSON with Arduino for making a POST request

drop-down menu displaying the major cities will be at the top

What is the best way to call an Angular component function from a global function, ensuring compatibility with IE11?

Binding data in a Listbox on Windows Phone 8.0

Exploring C# Programming with Jack

Angular Delight: Jaw-Dropping Animation

Incorrect typings being output by rxjs map

openapi-generator is generating subpar api documentation for TypeScript

Plugin refresh after callback

Is there a more efficient method for providing hooks to children in React when using TypeScript?

What is the best way to transform a JavaScript object into an array?

Create new instances of Backbone Models using an existing Backbone Model as a template

What is the process for checking pending requests within Azure Application Insights?

What is the maximum character limit for jQuery?

In Python/Django, the accent character is replaced with xed

A guide on retrieving JSON data from an AJAX request using Angular UI Bootstrap

The JSON Post Request functionality is encountering issues within ASP.NET5 MVC, whereas it is functioning properly in ASP.NET4.5 MVC

Refine the JSON data to only include the values you need