Mapperly: eenvoudiger, sneller en overzichtelijker objecten mappen

Christian van Dijk - Cloud Republic - 13-02-2025

De meeste van ons komen uit op AutoMapper, de standaard library voor het maken van .NET-mappers. Maar AutoMapper, handmatige mappings en andere soortgelijke tools kunnen rommelig worden, waardoor overzicht houden lastig is: je wilt zien welke eigenschappen je vergeet te mappen of welke mappings er ontbreken. Maar, er is een nieuwkomer die belooft de zaken eenvoudiger en efficiënter te maken. 

Hier komt Mapperly in beeld: een nieuwe library die mappers creëert met behulp van source generation.

Wat is Mapperly? 

Mapperly is een library die het proces van mappen tussen objecten aanzienlijk vereenvoudigt door gebruik te maken van source generation. Dit betekent dat Mapperly tijdens de compileertijd de mappingcode genereert, waardoor je geen runtime-overhead hebt. Het resultaat: sneller en overzichtelijker werken, zonder gedoe. 

Waarom Mapperly? 

Met Mapperly zie je precies welke eigenschappen je vergeet te mappen. Dit voorkomt frustratie en uren debuggen om fouten in grote mappers te achterhalen. Bovendien biedt Mapperly een overzichtelijke en efficiënte workflow, waardoor je tijd en moeite bespaart. 

Mapperly biedt een aantal grote voordelen: 

  • Snelheid: Het gebruikt geen reflectie. 
  • Betere gebruikerservaring (DX): Het helpt je om overzicht te houden en geen fouten te maken. 
  • Eenvoudig te leren: Het draait voornamelijk om attributen. 

Laten we eens kijken hoe je Mapperly kunt gebruiken, beginnend met een eenvoudig voorbeeld. 

Eenvoudige mapping met Mapperly 

We beginnen met een voorbeeld van twee eenvoudige modellen die we willen mappen, met slechts kleine verschillen: 

Model A

public class Dragon

{

public string Name { get; set; }

public int Age { get; set; }

public Element Element { get; set; }

public Dragon[] Children { get; set; }

}

 

public enum Element

{

Fire,

Water,

Earth,

Air,

Electric

}

Model B

public class DragonModel

{

public string Name { get; set; }

public int Age { get; set; }

public string Element { get; set; }

public DragonModel[] Children { get; set; }

}

Onze mapper om tussen beide modellen te mappen ziet er als volgt uit: 

[Mapper]

public partial class DragonMapper

{

public partial DragonModel Map(Dragon dragon);

public partial Dragon Map(DragonModel dragonModel);

}

In dit voorbeeld gebruiken beide methoden de naam ‘Map‘, maar je kunt ook explicietere namen kiezen als dat je voorkeur heeft. Dit ziet er eenvoudig en overzichtelijk uit, nietwaar? Let op het gebruik van het keyword ‘partial‘. Dit is nodig omdat de daadwerkelijke mappingcode door Mapperly wordt gegenereerd tijdens het compileren. Mapperly genereert volledig leesbare code. Hier is een fragment van de gegenereerde code: 

public partial class DragonMapper

{

[global::System.CodeDom.Compiler.GeneratedCode("Riok.Mapperly", "4.1.1.0")]

public partial global::DragonMapperly.Simple.DragonModel Map(global::DragonMapperly.Simple.Dragon dragon)

{

var target = new global::DragonMapperly.Simple.DragonModel();

target.Name = dragon.Name;

target.Age = dragon.Age;

target.Element = MapToString(dragon.Element);

target.Children = MapToDragonModelArray(dragon.Children);

return target;

}

...

Zoals je ziet, genereert Mapperly een nette en duidelijke mapping. 

Complexere mapping: Geneste modellen 

Nu proberen we een meer complexe mapping, waarbij we laten zien hoe geneste modellen worden gemapt, overbodige eigenschappen worden genegeerd en waarden worden gegenereerd voor anders lege velden. 

Model C bevat een nieuw ID veld en een veld van type Origin: 

public class Dragon

{

public Guid Id { get; set; }

public string Name { get; set; }

public int Age { get; set; }

public Origin Origin { get; set; }

public Element Element { get; set; }

public Dragon[] Children { get; set; }

}

 

public class Origin

{

public string CountryName { get; set; }

public string Continent { get; set; }

}

Model D negeert het Id veld en gebruikt niet het geneste Origin veld: 

public class DragonModel

{

public string Name { get; set; }

public int Age { get; set; }

public string Element { get; set; }

public DragonModel[] Children { get; set; }

public string CountryName { get; set; }

public string Continent { get; set; }

}

Wanneer we bijvoorbeeld de Id-eigenschap toevoegen aan de Dragon, geeft Mapperly een waarschuwing in de IDE: 

  • The member ‘Id‘ on the mapping source type Dragon is not mapped to any member on the mapping target type ‘DragonModel‘. 

Deze waarschuwing helpt ons om fouten te vermijden. Laten we dit oplossen door de ‘Id-eigenschap‘ te negeren bij het mappen van ‘Dragon‘ naar ‘DragonModel‘. Daarnaast genereren we een nieuwe ‘Guid‘ wanneer we van ‘DragonModel‘ naar ‘Dragon‘ mappen. Onze mapper ziet er nu als volgt uit: 

[Mapper]

public partial class DragonMapper

{

[MapperIgnoreSource(nameof(Dragon.Id))]

[MapNestedProperties(nameof(Dragon.Origin))]

public partial DragonModel Map(Dragon dragon);

 

[MapValue(nameof(Dragon.Id), Use=nameof(GenerateGuid))]

[MapProperty(nameof(DragonModel.CountryName), nameof(Dragon.Origin.CountryName))]

[MapProperty(nameof(DragonModel.Continent), nameof(Dragon.Origin.Continent))]

public partial Dragon Map(DragonModel dragonModel);

 

private static Guid GenerateGuid() => Guid.NewGuid();

}

Makkelijk genoeg, toch? Met de ‘Use’ notatie kunnen we elke methode gebruiken die we willen, en dit is erg handig voor het genereren van values of het gebruiken van andere Mapperly mapping methodes. 

Conclusie 

Mapperly maakt het mappen van objecten eenvoudiger, sneller en overzichtelijker. Met duidelijke waarschuwingen en automatisch gegenereerde code helpt het je fouten te voorkomen en je ontwikkelingsproces te versnellen. Probeer Mapperly vandaag nog uit in je volgende app of project en ontdek hoe het jouw workflow kan verbeteren!

An unhandled error has occurred. Reload 🗙