Primo contatto con Mapperly

Mapperly è un generatore di codice sorgente (source generator) per la mappatura di oggetti in .NET, il che lo distingue significativamente da librerie come AutoMapper.

Ecco le sue caratteristiche chiave:

• Generazione del Codice in Fase di Compilazione (Compile-time Code Generation):
  • Questa è la sua caratteristica distintiva più importante. A differenza di AutoMapper che utilizza la reflection a runtime per scoprire e applicare le mappature, Mapperly genera il codice di mappatura effettivo durante la compilazione del tuo progetto.
  • Questo significa che non c’è alcun overhead di runtime dovuto alla riflessione. Le mappature sono eseguite come semplice codice C# compilato, rendendole incredibilmente veloci, spesso tanto veloci quanto una mappatura manuale.
• Zero Overhead a Runtime:
  • Poiché il codice è generato in anticipo, Mapperly non ha nessun impatto sulle prestazioni a runtime. Non ci sono lookup di tipi, cache o altre operazioni che potrebbero rallentare l’applicazione. È puro codice C# eseguito.
• Sicurezza del Tipo (Type-Safety) e Analisi Statica:
  • Grazie alla generazione in fase di compilazione, Mapperly offre una completa sicurezza del tipo. Se tenti di mappare un tipo a un altro in modo non compatibile, il compilatore ti avviserà con un errore di compilazione.
  • Questo migliora notevolmente l’analisi statica del tuo codice. Errori di mappatura che con AutoMapper potrebbero emergere solo a runtime, con Mapperly vengono catturati molto prima, durante lo sviluppo.
• Semplicità e Convenzione Over Configurazione:
  • Mapperly si basa molto sulla convenzione dei nomi. Se i nomi delle proprietà tra l’oggetto sorgente e quello di destinazione corrispondono, Mapperly genererà automaticamente il codice per mapparli.
  • La configurazione esplicita è necessaria solo per scenari più complessi o quando le convenzioni non bastano (ad esempio, per nomi diversi, mappature condizionali o trasformazioni). Questo viene fatto tramite attributi C# semplici e intuitivi.
• Codice Generato Leggibile e Debuggabile:
  • Il codice C# generato da Mapperly è progettato per essere leggibile e facile da capire. Puoi ispezionarlo direttamente nella tua IDE (ad esempio, Visual Studio) per vedere esattamente come viene eseguita la mappatura.
  • Questo rende il debugging molto più semplice, poiché puoi seguire passo passo il codice di mappatura come faresti con qualsiasi altro codice C# scritto a mano.
• Integrazione con la Pipeline di Build:
  • Essendo un generatore di sorgente, Mapperly si integra perfettamente nella tua pipeline di build .NET. Non richiede passaggi aggiuntivi o strumenti esterni. Basta installare il pacchetto NuGet.
• Supporto per Scenari Complessi:
  • Nonostante la sua semplicità di base, Mapperly supporta anche scenari più avanzati come:
    • Mappature nidificate
    • Ignorare proprietà
    • Mappature condizionali
    • Metodi di mappatura personalizzati (per logiche complesse non gestite automaticamente)
    • Mappatura di collezioni (List<T>, IEnumerable<T>)
    • Mappatura inversa (anche se non automatica come AutoMapper, richiede definizioni esplicite).

In sintesi, Mapperly mira a fornire il meglio di entrambi i mondi: la convenienza di un mapper automatico con le prestazioni e la sicurezza del tipo della mappatura manuale, eliminando l’overhead della reflection. È un’ottima scelta per progetti dove le prestazioni e la robustezza del codice sono prioritarie.