context.GetInput returns base class instead of specified derived class in $Type

Question

Using Azure Durable Functions, I am trying to use the context.GetInput<model>() function which returns the specified model. The model being used has a parameter that is another model which is a derived class. The model that is outputted from context.GetInput<model>() returns the model with the base class instead of the derived class.

I have checked the $type specified in the context, which shows the derived class, but when checking the outputted model, the result is the base class.

for example:

public class Student{
   public Book book {get;set;}
}

public class Textbook:Book {
   public string classfor {get;set;}
}

public class Book {
   public string title {get;set;}
}

[ActivityTrigger] DurableActivityContextBase context is a parameter to the function.

Then I would be calling :

var model = context.GetInput<Student>()

where the context includes

{
  "$type": "Student",
    "book" : {
       "$type": "Textbook",
       "classfor" : "Math",
       "title" : "PreAlgebra"
    }
}

Yet the result is Model of student which contains a Book instead of Textbook, where the title is assigned "PreAlgebra"

I expect the output of Student model to have a Textbook with properties:

title = "PreAlgebra"
classfor = "Math"

but the actual Student output contains a Book with the property

title = "PreAlgebra"

Answer 1

I've encountered the same problem you did last week. Unfortunately right now Azure Functions (even 2.x) don't support polymorphism for durable functions. The durable context serializes your object to JSON, but there's no way to pass JSON serialization settings as described here on GitHub. There's also another issue about this specific problem.

In my case I have an abstract base class, but you can use the same approach for your derived types. You can create a custom JSON converter that will deal with picking the correct type during deserialization. So for example if you have this sort of inheritance:

[JsonConverter(typeof(DerivedTypeConverter))]
public abstract class Base
{ 
    [JsonProperty("$type")]
    public abstract string Type { get; }
}

public class Child : Base
{
    public override string Type => nameof(Child);
}

public class Child2 : Base
{
    public override string Type => nameof(Child2);
}

Then you can have your а JSON Converter:

public class BaseDerivedTypeConverter : DefaultContractResolver
{
    // You need this to protect yourself against circular dependencies
    protected override JsonConverter ResolveContractConverter(Type objectType)
    {
        return typeof(Base).IsAssignableFrom(objectType) && !objectType.IsAbstract
            ? null
            : base.ResolveContractConverter(objectType);
    }
}

public class DerivedTypeConverter : JsonConverter
{
    private static readonly JsonSerializerSettings Settings =
        new JsonSerializerSettings()
        {
            ContractResolver = new BaseDerivedTypeConverter()
        };

    public override bool CanConvert(Type objectType) => (objectType == typeof(Base));

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

        // Make checks if jsonObject["$type"].Value<string>() has a supported type
        // You can have a static dictionary or a const array of supported types

        // You can leverage the array or dictionary to get the type you want again
        var type = Type.GetType("Full namespace to the type you want", false); // the false flag means that the method call won't throw an exception on error

        if (type != null)
        {
            return JsonConvert.DeserializeObject(jsonObject.ToString(), type, Settings);
        }
        else
        {
            throw new ValidationException("No valid $type has been specified!");
        }
    }

    public override bool CanWrite => false;

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

In my usage when I call context.GetInput<Base>() I can get either Child or Child1 because Base is abstract.

In your case it can be Book or Student depending on what's the actual value. This also applies for other durable function operations like like

var foobar = await context.CallActivityAsync<Base>("FuncName", context.GetInput<int>());

The converter will deal with that and you'll get the object you want inside foobar.

Answer 2

Per my understanding, the class Textbook extends Book, so "Book" is parent class and "Textbook" is subclass. In your context, you want to turn the child class(Textbook) to the parent class(Book). After that, "book" will just have the attribute "title" which is their common attribute but doesn't have the specific attribute "classfor". You can refer to the code below:

Answer 3

Tracked the updates to pass in Json serialization to Azure Functions here showing that it will be in v2.1!