Instantiate record types from dynamic data with compatible structural shapes, in-memory with no reflection or serialization, via compile-time source generators.
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);
}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.
For the above example with Drawing/Line/Point records, you'd get a generated
Dynamically type like:
static partial class Dynamically
{
public static partial T Create<T>(dynamic data)
{
return typeof(T) switch
{
Type t when t == typeof(Drawing) => (T)Drawing.Create(data),
_ => throw new NotSupportedException(),
};
}
}If the Drawing record was partial, the Create method would look like:
partial record Drawing
{
public static Drawing Create(dynamic value)
=> DrawingFactory.Create(value);
}With the DrawingFactory class being generated as:
static partial class DrawingFactory
{
public static Drawing Create(dynamic value)
{
if (value is null)
throw new ArgumentNullException(nameof(value));
try
{
return new Drawing(Line.CreateMany(value.Lines));
}
catch (RuntimeBinderException e)
{
var valueAsm = ((object)value).GetType().Assembly.GetName();
var thisAsm = typeof(DrawingFactory).Assembly.GetName();
throw new ArgumentException(
$"Incompatible {nameof(Drawing)} value. Cannot convert value from '{valueAsm.Name}, Version={valueAsm.Version}' to '{thisAsm.Name}, Version={thisAsm.Version}'.",
nameof(value), e);
}
}
public static List<Drawing> CreateMany(dynamic value)
{
var result = new List<Drawing>();
foreach (var item in value)
{
result.Add(Create(item));
}
return result;
}
}The Line factory method would look very similar, instantiating a many points,
with perhaps Point being the most interesting:
static partial class PointFactory
{
public static Point Create(dynamic value)
{
if (value is null)
throw new ArgumentNullException(nameof(value));
try
{
return new Point((global::System.Int32)value.X, (global::System.Int32)value.Y);
}
catch (RuntimeBinderException e)
{
var valueAsm = ((object)value).GetType().Assembly.GetName();
var thisAsm = typeof(PointFactory).Assembly.GetName();
throw new ArgumentException(
$"Incompatible {nameof(Point)} value. Cannot convert value from '{valueAsm.Name}, Version={valueAsm.Version}' to '{thisAsm.Name}, Version={thisAsm.Version}'.",
nameof(value), e);
}
}
public static List<Point> CreateMany(dynamic value)
{
var result = new List<Point>();
foreach (var item in value)
{
result.Add(Create(item));
}
return result;
}
}As you can see, the factory methods are very simple and straightforward, and have great run-time performance characteristics since there is absolutely no reflection, and the built-in C# dynamic infrastructure takes care of doing the heavy lifting. The generated code is basically what you'd write manually to do the casting of the entire object hierarchy.
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.
We also produce CI packages from branches and pull requests so you can dogfood builds as quickly as they are produced.
The CI feed is https://pkg.kzu.app/index.json.
The versioning scheme for packages is:
- PR builds: 42.42.42-pr
[NUMBER] - Branch builds: 42.42.42-
[BRANCH].[COMMITS]
