Entity-Property mapping

Question

Entity-Property mapping

How do we map the entities/properties from a JSON to another JSON with a different format/structure? The input JSON is complex and has multiple levels and array elements. This needs to be deserialized and mapped to another Entity.

I am planning to use the DB to store mapping configurations, ex: source property "id" maps to destination property "Identifier" etc

I have been trying to use strongly typed C# model classes to deserialize and map to the destination model, however I am aware that this is not a very extensible solution and any changes in the source/destination JSON payload would require code and DB changes.

Is there any solution that is configurable and dynamic, that can solve this problem?

Answer 1

Alan Farias 650

One solution to map entities/properties from one JSON to another with a different structure is to use a tool or library that supports mapping, such as AutoMapper. AutoMapper is a widely used open-source library for .NET that enables object-object mapping. You can define mapping configurations in code, such as property names, and use them to map between different object types. It supports complex object graphs and collections, and also supports custom mapping logic.

Another approach is to use a configuration-based mapping tool like FRENDS Mapper. FRENDS Mapper is an integration platform that provides a visual editor for creating and managing data mappings between different formats, such as JSON, XML, CSV, and SQL. With FRENDS Mapper, you can define mapping rules and transformations using a graphical user interface, and store them in a configuration file. This approach allows you to easily modify mappings without changing code or making database changes.

Regarding the use of the database to store mapping configurations, this is a good approach as it allows you to separate the mapping logic from the application code and provides a more flexible solution. You can define the mapping rules and configurations in a database table and retrieve them at runtime, then use them to dynamically map the objects. This approach allows you to modify the mapping configurations without redeploying the application. However, it requires careful design and management of the database table to ensure scalability, maintainability, and security.

In summary, there are several tools and approaches that you can use to map entities/properties from one JSON to another with a different structure. AutoMapper and FRENDS Mapper are two examples of tools that you can use, while storing mapping configurations in a database is a good practice that can improve flexibility and maintainability.

Vikhyath Shetty 25 Reputation points

2023-03-03T06:37:47.6033333+00:00

Thanks Alan. I have tried using Automapper using the "IMappingExpression" interface to retrieve DB configs and use it for mapping at runtime. However it seems to fail while trying to parse any object beyond the first level, so not sure how to proceed. If you have sample code for mapping complex JSON object (multiple levels) using DB configurations that would be very helpful. Also, can you share some links for FRENDS Mapper?

Alan Farias 650

Certainly! Here's some sample code that demonstrates using AutoMapper to map a complex JSON object with multiple levels using DB configurations:
I reinforce that this is just an example, so you have an idea of where to start. It may not fully meet your scenario or have some errors. But you might have an idea.

Please, if my answer helped you, mark it as accepted.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using AutoMapper;

public class SourceObject
{
    public int Id { get; set; }
    public string Name { get; set; }
    public SourceSubObject SubObject { get; set; }
}

public class SourceSubObject
{
    public int SubId { get; set; }
    public string SubName { get; set; }
}

public class DestinationObject
{
    public int Identifier { get; set; }
    public string FullName { get; set; }
    public DestinationSubObject SubObject { get; set; }
}

public class DestinationSubObject
{
    public int SubIdentifier { get; set; }
    public string SubFullName { get; set; }
}

public static class MappingManager
{
    private static IMapper _mapper;

    static MappingManager()
    {
        var configuration = new MapperConfiguration(cfg =>
        {
            cfg.CreateMap<SourceObject, DestinationObject>();
            cfg.CreateMap<SourceSubObject, DestinationSubObject>();
        });

        _mapper = configuration.CreateMapper();
    }

    public static IMapper GetMapper()
    {
        return _mapper;
    }

    public static void ConfigureMappingsFromDb(string connectionString)
    {
        using (var connection = new SqlConnection(connectionString))
        {
            connection.Open();

            using (var command = new SqlCommand("SELECT * FROM MappingConfigurations", connection))
            {
                var reader = command.ExecuteReader();

                while (reader.Read())
                {
                    var sourcePropertyName = (string)reader["SourcePropertyName"];
                    var destinationPropertyName = (string)reader["DestinationPropertyName"];

                    var sourceType = Type.GetType((string)reader["SourceType"]);
                    var destinationType = Type.GetType((string)reader["DestinationType"]);

                    var sourcePropertyInfo = sourceType.GetProperty(sourcePropertyName);
                    var destinationPropertyInfo = destinationType.GetProperty(destinationPropertyName);

                    Mapper.CreateMap(sourceType, destinationType)
                          .ForMember(destinationPropertyInfo, opt => opt.MapFrom(sourcePropertyInfo));
                }
            }
        }
    }
}

// Usage example
var connectionString = "your connection string";
MappingManager.ConfigureMappingsFromDb(connectionString);

var sourceObject = new SourceObject
{
    Id = 1,
    Name = "John",
    SubObject = new SourceSubObject
    {
        SubId = 2,
        SubName = "Doe"
    }
};

var destinationObject = MappingManager.GetMapper().Map<SourceObject, DestinationObject>(sourceObject);

In this example, MappingManager is a helper class that is responsible for creating and configuring the IMapper instance with the necessary mapping configurations from the database. The ConfigureMappingsFromDb method retrieves the mapping configurations from the database table named MappingConfigurations and creates the necessary mappings using Mapper.CreateMap method. This approach allows you to easily modify the mapping configurations in the database without redeploying the application.

As for FRENDS Mapper, you can find more information on their website: https://frends.com/mapper/. They offer a free trial as well as various pricing plans depending on your needs.

Entity-Property mapping

1 answer

Activity