Come iniziare con AutoMapper e ASP.NET Core 2

Foto di Catturare il cuore umano. su Unsplash

Se dovessi chiedere a un gruppo di sviluppatori ASP.NET di nominare i loro pacchetti più installati e utilizzati, sarei sorpreso se la maggior parte non avesse AutoMapper nella loro lista.

Al momento della stesura di questo articolo, AutoMapper su NuGet.org è stato scaricato 17.291.772 volte e si trova al primo posto tra i 100 pacchetti community più scaricati nelle ultime 6 settimane. Ma cos'è AutoMapper?

Logo di AutoMapper GitHub

Che cos'è AutoMapper?

Sono sicuro che sei stato in questo scenario innumerevoli volte: hai un'applicazione web ASP.NET e vuoi mantenere la separazione tra i tuoi modelli di dominio e i tuoi modelli di visualizzazione. Quindi scrivi il codice che ti consente di mappare il tuo modello di dominio nel tuo modello di visualizzazione. Quindi, quando aggiungi più viste e modelli di dominio, finisci per scrivere più mapper. Quindi scrivi mappatori per mappare gli oggetti di trasferimento del dominio dal livello del database agli oggetti del tuo dominio ... ottieni il punto.

Questo codice è banale e ripetitivo. Ed è qui che entra in gioco AutoMapper. È un mappatore da oggetto a oggetto basato su convenzione che richiede poca configurazione.

AutoMapper è un mappatore oggetto-oggetto basato su convenzione che richiede poca configurazione.

Ecco come puoi iniziare con AutoMapper.

Introduzione a AutoMapper

Passaggio 1: installazione di AutoMapper

Per questo esempio dovrai creare un'applicazione web ASP.NET Core 2 (sto usando Visual Studio 2017 in Windows).

Esistono un paio di modi in cui è possibile installare AutoMapper, è possibile fare clic con il pulsante destro del mouse sul progetto Web e selezionare Gestisci pacchetti NuGet, quindi cercare e installare il pacchetto AutoMapper.Extensions.Microsoft.DependencyInjection.

In alternativa, è possibile utilizzare la console di Gestione pacchetti con il comando seguente:

Installa pacchetto AutoMapper.Extensions.Microsoft.DependencyInjection

Installando il pacchetto AutoMapper.Extensions.Microsoft.DependencyInjection, installerà automaticamente anche il pacchetto AutoMapper.

Passaggio 2: configurazione di AutoMapper

Ora puoi andare avanti e configurare AutoMapper nella tua classe Startup.cs con il metodo ConfigureServices:

Creiamo un modello utente nella cartella Modelli:

Insieme al nostro modello utente vogliamo anche creare un nuovo ViewModel che verrà eventualmente utilizzato per visualizzare i dati dei nostri utenti:

Ora abbiamo il nostro modello utente e il nostro modello utente View, come possiamo dire ad AutoMapper di mappare dalla nostra modalità utente al nostro ViewModel utente? Bene, usiamo un profilo.

I profili in AutoMapper sono un buon modo di organizzare le raccolte di mappe. Per creare un profilo, creiamo una nuova classe ed ereditiamo dal profilo. Possiamo quindi aggiungere la nostra configurazione di mappatura all'interno del nostro nuovo costruttore di classi.

Vai a testa e crea una classe UserProfile per mappare il nostro modello utente al nostro ViewModel utente:

Ora abbiamo una classe UserProfile che crea il mapping tra il nostro Modello utente e il ViewModel utente. Ma come fa AutoMapper a conoscere la nostra classe UserProfile?

Bene, se ricordi, all'inizio di questo esempio abbiamo aggiunto questa riga di codice al nostro metodo ConfigureServices in Startup.cs:

Quando la nostra applicazione si avvia e aggiunge AutoMapper, AutoMapper eseguirà la scansione del nostro assieme e cercherà le classi che ereditano dal profilo, quindi caricherà le loro configurazioni di mappatura.

Passaggio 3: AutoMapper in azione

Creiamo un nuovo UserController nella cartella Controller:

Per usare i nostri mapping configurati, dobbiamo iniettare l'interfaccia IMapper nel costruttore della nostra classe UserController:

Come per i profili, chiamando AddAutoMapper nel nostro metodo ConfigureServices Startup.cs, ci siamo occupati della registrazione di IMapper per noi.

Nel nostro metodo di azione indice, creiamo un oggetto utente:

Ora possiamo usare l'interfaccia IMapper che abbiamo iniettato nel nostro costruttore e chiamare il metodo Map.

Diamo al metodo Map il tipo che vogliamo mappare e l'oggetto da cui vorremmo mappare:

Nel codice sopra, ho anche passato il nostro User ViewModel appena mappato nella vista.

Finalmente, ora possiamo creare una vista per il nostro controller usando il nostro ViewModel utente:

Tempo per la grande rivelazione: esegui l'applicazione e vai a / utente (nel mio caso sono andato a http: // localhost: 64877 / utente):

Ecco fatto: dovresti essere in grado di vedere le proprietà che abbiamo usato durante la creazione del nostro utente sono state mappate al nostro ViewModel utente e ora vengono mostrate.

Conclusione

Con Automapper è possibile mappare un oggetto a un altro in tutta l'applicazione con una piccola configurazione.

Abbiamo appena graffiato la superficie di ciò che AutoMapper ha da offrire in termini di mappatura degli oggetti l'uno dall'altro, ma spero che tu possa vedere quanto sia facile installarsi e utilizzarlo.

Ti incoraggio a continuare ad esplorare il set di funzionalità e gli usi di AutoMapper nel link della documentazione qui sotto.

risorse:

Jimmy Bogard
 automapper
 AutoMapper - Documentazione
 NuGet