Devlooped.Dynamically 1.0.1

Create record types from dynamic data with a compatible structural shape.

Usage

Create records for your data types:

public record Point(int X, int Y);

public record Line(Point Start, Point End);

public record Drawing(Line[] Lines);

This project will generate a Dynamically class with a factory method to create instances of those records from a data object with a compatible shape, such as:

var data = new
{
    Lines = new[]
    {
        new
        {
            Start = new { X = 50, Y = 0 },
            End = new { X = 0, Y = 100 },
        },
        new
        {
            Start = new { X = 50, Y = 0 },
            End = new { X = 0, Y = 100 },
        }
    }
};

Drawing drawing = Dynamically.Create<Drawing>(data);

In adition to a dynamic object (or an ExpandoObject, for example), you can also pass in objects from other strongly typed values that come from a different assembly as long as it has the same structure. This allows fast in-memory object mapping without any serialization or extra allocations.

The factory works too for Newtonsoft.Json deserialized objects, for example:

// elsewhere, you got an in-memory Json.NET object model, perhaps with:
dynamic data = JsonConvert.DeserializeObject(json);

// Subsequently, you can turn it into your strongly-typed records:
Drawing drawing = Dynamically.Create<Drawing>(data);

You can also optionally customize the mapping for specific records by providing accessible static Create or CreateMany factory methods in your records, so you can selectively customize the mapping by providing them as needed in specific cases. For example:

partial record Drawing
{
    // Customize creation of a single Drawing from a dynamic value
    public static Drawing Create(dynamic value);
    // Customize creation of a list of Drawings from a dynamic value
    public static List<Drawing> CreateMany(dynamic value);
}

How It Works

This package analyzes (at compile-time) the shape of your records and creates a factory that create instances from a dynamic object. For this, it just accesses the properties of the dynamic object and passes them to the record constructor (or its properties). This means that the data must have (at least) the expected values for the conversion to succeed.

The static Dynamically.Create generic method is also generated at compile time and contains a switch statement that dispatches to the correct factory based on the generic argument specified.

In addition, if the records are partial, you also get static Create and CreateMany static methods on the record type itself, for added convenience, such as:

partial record Drawing
{
    public static Drawing Create(dynamic value);
    public static List<Drawing> CreateMany(dynamic value);
}

NOTE: these will only be provided if your record doesn't already have them.

Limitations

This package is not meant to be a full-fledged object mapper. For that, you can use AutoMapper, for example, which is much more flexible and has excelent performance characteristics. This package does provide very fast in-memory object mapping that is far faster and cheaper than going through any sort of serialization.

As mentioned, the provided factories do not provide backwards-compatibility: if you add a property or constructor argument to the record, the factory will fail for payloads without it.

Sponsors

Learn more about GitHub Sponsors