Polymorphism In Web API .Net Core 6

Introduction

In some WebAPI projects, I was asked to optimize the number of links that the API exposes. It means that we want to simplify the configuration on the client side.

To do this, polymorphism can be a good approach. It means that while designing the models, we have to think on having an abstraction for the common attributes of the data, then extend them according to the need. The controller will know what to do according to the type of payload provided by the client.

ASP.Net core gives the possibility to do a such thing. In this article, we will see how to send different structure of payload using the same controller in the WebAPI

What is Polymorphism?

Polymorphism is a term that comes from the ancient greek language: Polus (several) and Morphe (Form) and in Object Oriented Programming it means the ability of an object to have several forms.

This can be done by defining a base class and inheriting it from daughter classes. Then the base class can be instantiated in several ways according to the daughter classes. Our Data Model shows a real example of polymorphism.

Data Model

In our case, we will suppose that we have a base class called Device which is derived from two other classes Phone and Laptop.

Here we want to have only one controller that allows to Post a device independently from its type. The controller will know how to deserialize the object according to the attribute DeviceType.

Then in the Get method we will return a list of devices, here again, the controller will be able to deserialize and return the right format of JSON.

Prerequisite

  • Visual Studio 2022
  • Net Core 6.0

Implementation

Step 1 - Creation of the WebApi Project

You need to create Asp.Net Core Web API in Visual Studio

Step 2 - Nuget Packages

Ensure that you have the following nuget packages referenced in your solution

Step 3 - Definition of the Classes

Now you should define the model into classes, the first one to define is the base class Device

namespace PolymorphismInWebApi.Models.Abstract
{
    public abstract class Device
    {
        public string SerialNumber { get; set; }
        public string Brand { get; set; }
        public string ScreenSize { get; set; }
        public string RAM { get; set; }
        public string Storage { get; set; }
        public double Price { get; set; }
    }
}

And then the two derived classes Phone and Laptop

Laptop

using PolymorphismInWebApi.Models.Abstract;

namespace PolymorphismInWebApi.Models
{
    public class Laptop : Device
    {
        public int NumborOfUsbPort { get; set; }
        public bool HasHdmiPort { get; set; }
        public bool HasDvdReader { get; set; }
    }
}

Phone

using PolymorphismInWebApi.Models.Abstract;

namespace PolymorphismInWebApi.Models
{
    public class Phone : Device
    {
       public bool IsSmartPhone { get; set; }
       public int NumberOfSimCard { get; set; }
       public List<string> Sensors { get; set; }
    }
}

You can notice here that in our model we defined an attribute DeviceType, but we didn't define it in any of our classes. This attribute is called the discriminator.

It's the one that will allow the controller to make the difference between the different forms of the object when it's received in the payload. We will see how to use the discriminator in the next section.

But at this level, we need to define this discriminator as an enumeration for example

namespace PolymorphismInWebApi.Models.Enumeration
{
    public enum DeviceTypeEnum
    {
        Phone,
        Laptop
    }
}

Step 4 - Initialization of the WebApi

Now you've created your classes, you need to tell your WebApi that it will use the relation between them to receive request from the clients.

This is done during the initialization in Program.cs. It can be done by the following code (check the comments for details)

using PolymorphismInWebApi.Utils;
using JsonSubTypes;
using Microsoft.OpenApi.Models;
using PolymorphismInWebApi.Models.Abstract;
using PolymorphismInWebApi.Models;
using PolymorphismInWebApi.Models.Enumeration;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers().AddNewtonsoftJson(options =>
{
    //Register the subtypes of the Device (Phone and Laptop)
    //and define the device Discriminator
    options.SerializerSettings.Converters.Add(
        JsonSubtypesConverterBuilder
        .Of(typeof(Device),CommonData.DeviceDiscriminator)
        .RegisterSubtype(typeof(Phone), DeviceTypeEnum.Phone)
        .RegisterSubtype(typeof(Laptop), DeviceTypeEnum.Laptop)
        .SerializeDiscriminatorProperty()
        .Build()
    );
   
});
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();

//Add the features of Polymorphism to the swagger
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", 
                    new OpenApiInfo 
                    { 
                        Title = "PolymorphismInWebApi", 
                        Version = "v1" }
                );
        c.UseAllOfToExtendReferenceSchemas();
        c.UseAllOfForInheritance();
        c.UseOneOfForPolymorphism();
        c.SelectDiscriminatorNameUsing(type =>
        {
            return type.Name switch
            {
                nameof(Device) => CommonData.DeviceDiscriminator,
                _ => null
            };
        });   
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment()) {
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

Step 5 - Implementation of the Controller

Now you can define your controller with only the base class Device as parameter in the payload.

You can pass the specific attributes of the derived classes Laptop or the Phone in the calls.

In the implementation of the Post Method, you can test the derived type of the passed parameter and check how to cast it and add it to the list.

I've used a static List to able to test the exchanged data

using PolymorphismInWebApi.Models;
using Microsoft.AspNetCore.Mvc;
using PolymorphismInWebApi.Models.Abstract;

namespace PolymorphismInWebApi.Controllers {
    [ApiController]
    [Route("[controller]")]
    public class DeviceController: ControllerBase {
        private readonly ILogger < DeviceController > _logger;
        public DeviceController(ILogger < DeviceController > logger) {
            _logger = logger;
        }
        private static List < Device > _devices = new List < Device > ();
        [HttpGet()]
        public List < Device > GetDevices() {
                return _devices;
            }
            [HttpPost]
        public void Post(Device device) {
            if (device is Phone) {
                _devices.Add((Phone) device);
            }
            if (device is Laptop) {
                _devices.Add((Laptop) device);
            }
        }
    }
}

Step 6 - Testing the WebApi using the Swagger

Now you can test the API using the swagger. But before starting to send the requests, let's see what's interesting about the specification of the current Implementation.

If you check the JSON specification of the swagger

You will notice that the polymorphism and the relationship between the objects is defined using the keyword OneOf (already called in Program.cs)

Now you can send two different structure of Payload using the same URL

Phone

{
  "DeviceType": "Phone",
  "serialNumber": "Ph123456789",
  "brand": "Samsung",
  "screenSize": "8",
  "ram": "3Gb",
  "storage": "64Gb",
  "price": 500,
  "IsSmartPhone": true,
  "NumberOfSimCard": 2,
  "Sensors": ["Gyroscope","Gps"]
}

Laptop

{
  "DeviceType": "Laptop",
  "serialNumber": "Lp123456789",
  "brand": "Dell",
  "screenSize": "17",
  "ram": "16Gb",
  "storage": "1To",
  "price": 2000,
  "numborOfUsbPort": 3,
  "hasHdmiPort": true,
  "hasDvdReader": false
}

You can add the previous Payloads and then check that you are able to receive them while getting the list

Conclusion

Finally, we can conclude that polymorphism can be a very interesting concept to make the web API more generic and the controllers more flexible in term of payloads.

But when it's implemented on the server side, it should be well communicated and specified to the client side. If the developer on the client side will use a proxy generator, for example, he needs to do a couple of things that we can see in a coming article.


Similar Articles