Flattening generator

The generator allows you to generate flattened classes from rich domain classes.

Installation

  dotnet add package Kros.Generators.Flattening

How to use it

Sometimes you need to create a class from your domain that has flattened properties (does not contain composite). For example, the class Person contains the Address property and the Town property. But you would need a class with the AddressTown property.

You define partial class and marke it with the Flatten attribute.

[Flatten(SourceType = typeof(Person))]
public partial class PersonFlat
{
}

And that's it. The generator will generate a partial class for you, which will contain all the necessary properties.

Another example

You have the following domain classes and value objects.

public class Document
{
    public Contact Owner { get; set; }

    public Contact Collaborator { get; set; }

    public string Name { get; set; }
}

public class Contact
{
    public string Name { get; set; }

    public Address Address { get; set; }
}

public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

And you want a flattened class, but with some exceptions.

[Flatten(SourceType = typeof(Document))]
[FlattenPropertyName(SourcePropertyName = "Owner.Address.City", Name = "Town")]
[FlattenPropertyName(SourcePropertyName = "Collaborator.Address", Name = "")]
public partial class DocumentFlat
{
}

The generated class will look like this:

public partial class DocumentFlat
{
    public string OwnerName { get; set; }

    public string OwnerAddressTown { get; set; }

    public string OwnerAddressStreet { get; set; }

    public string CollaboratorName { get; set; }

    public string CollaboratorCity { get; set; }

    public string CollaboratorStreet { get; set; }

    public string Name { get; set; }
}

Settings

Skip

You may not want to generate some properties into the output flattened class. To do this, you can use the Skip parameter and define a list of properties to be ignored.

[Flatten(SourceType = typeof(Document),
    Skip = new string[] { nameof(Document.Collaborator)})]

DoNotFlatten

If you do not want to flatten any of the properties, use the parameter to do so DoNotFlatten.

[Flatten(SourceType = typeof(Document),
    DoNotFlatten = new string[] { nameof(Document.Owner) })]

Rename outup property

If you want to rename the output property, use the FlattenPropertyName attribute.

[FlattenPropertyName(SourcePropertyName = "Owner.Address.City", Name = "Town")]
[FlattenPropertyName(SourcePropertyName = "Collaborator.Address", Name = "")]

Mapping

This generator also generates ToComplex and FromComplex mapping methods for you.

ToComplex

Allows you to map a flat instance to its complex domain form.

DocumentFlat flat = new()
{
    OwnerAddressTown = "Wichita, KS 67202",
    OwnerAddressStreet = "1938 Roosevelt Road",
    OwnerName = "Jill A. Spurgeon",
    CollaboratorCity = "8282 Koprivnica",
    CollaboratorStreet = "Kolodvorska 28",
    CollaboratorName = "Christine M. Dudley",
    Name = "new document"
};

Document document = flat.ToComplex();

Or simply use the implicit conversion.

Document document = flat;

FromComplex

It allows you to create a flattened instance of your complex domain class.

DocumentFlat flat = DocumentFlat.FromComplex(document);

Or simply use the explicit conversion.

DocumentFlat flat = (DocumentFlat)document;

IEnumerable.ToComplex

It is possible to convert an entire collection of flattened instances to a collection of complex objects.

IEnumerable<DocumentFlat> flatDocuments = LoadData();

IEnumerable<Document> documents = flatDocuments.ToComplex<DocumentFlat, Document>();

Limitation

⚠ Mapping methods are generated only if all types contain a public parameterless constructor or a constructor that has the same parameters as the properties (case insensitive).