AutoMapper in C# con esempi
In questo articolo parlerò di AutoMapper in C# con alcuni semplici esempi. Alla fine di questo articolo, avrai un'ottima comprensione dei seguenti suggerimenti.
- Perché è necessario utilizzare AutoMapper in C#?
- Cos'è AutoMapper in C#?
- Come si usa AutoMapper in C#?
- Molti esempi per comprendere AutoMapper in C#.
- Cosa accadrà se i nomi delle proprietà di origine e di destinazione sono diversi?
- Come mappare due proprietà quando i nomi sono diversi usando automapper?
Perché abbiamo bisogno di AutoMapper in C#?
Capiamo perché abbiamo bisogno di automapper in C# con un esempio. Supponiamo di avere due classi come Impiegato e EmployeeDTO come mostrato nell'immagine qui sotto.
Ora, se vuoi copiare i dati o trasferire i dati dal Dipendente opporsi a EmployeeDTO oggetto, quindi nell'approccio tradizionale devi prima creare e popolare l'oggetto Dipendente come mostrato nell'immagine sottostante.
Una volta che hai l'oggetto impiegato, devi creare l'EmployeeDTO oggetto, nonché la necessità di copiare i dati dall'oggetto dipendente all'oggetto DTO dipendente come mostrato nell'immagine sottostante.
L'esempio completo è riportato di seguito.
L'esempio seguente copia i dati da un oggetto a un altro con l'approccio tradizionale, ovvero senza utilizzare l'automapper C#.
namespace AutoMapperDemo
{
class Program
{
static void Main(string[] args)
{
Employee emp = new Employee();
emp.Name = "James";
emp.Salary = 20000;
emp.Address = "London";
emp.Department = "IT";
EmployeeDTO empDTO = new EmployeeDTO();
empDTO.Name = emp.Name;
empDTO.Salary = emp.Salary;
empDTO.Address = emp.Address;
empDTO.Department = emp.Department;
Console.WriteLine("Name:" + empDTO.Name + ", Salary:" + empDTO.Salary + ", Address:" + empDTO.Address + ", Department:"+ empDTO.Department);
Console.ReadLine();
}
}
public class Employee
{
public string Name { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Department { get; set; }
}
public class EmployeeDTO
{
public string Name { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Department { get; set; }
}
} Ecco fatto. Ora, se esegui l'applicazione, otterrai l'output come previsto. Ma domani cosa farai se i dati, ovvero le proprietà nella classe, vengono aumentati. Quindi è necessario scrivere il codice per ogni dato di proprietà che si sposta dalla classe di origine alla classe di destinazione. Ciò significa che la mappatura del codice viene eseguita ancora e ancora tra l'origine e la destinazione.
Nei progetti in tempo reale, molte volte abbiamo bisogno di mappare gli oggetti tra i livelli UI/Dominio o Servizio/Dominio. La mappatura degli oggetti tra di loro è molto frenetica utilizzando l'approccio tradizionale di cui abbiamo discusso nell'esempio precedente. Quindi, esiste una soluzione più semplice con cui possiamo mappare due oggetti? Sì, c'è e la soluzione è AutoMapper .
Cos'è AutoMapper in C#?
L'AutoMapper in C# è un mappatore tra due oggetti. Cioè AutoMapper è un mappatore oggetto-oggetto. Mappa le proprietà di due diversi oggetti trasformando l'oggetto di input di un tipo nell'oggetto di output di un altro tipo.
Fornisce anche alcuni fatti interessanti per eliminare il lavoro sporco di capire come mappare un oggetto di tipo A con un oggetto di tipo B purché l'oggetto di tipo B segue la convenzione stabilita da AutoMapper. Man mano che avanzeremo in questo corso, vedrai la potenza dell'automapper.
Come si usa AutoMapper in C#?
Capiamo come usare automapper in C# con un semplice esempio usando un'applicazione console. Mapperemo lo stesso dipendente lezione con EmployeeDTO classe di cui abbiamo parlato nel primo esempio. Dobbiamo mappare ogni proprietà dei dipendenti alle corrispondenti proprietà EmployeeDTO utilizzando AutoMapper come mostrato nell'immagine sottostante.
Discutiamo la procedura dettagliata per utilizzare AutoMapper in C#.
Passaggio 1:installazione della libreria AutoMapper
AutoMapper è una libreria open source presente in GitHub . Per installare questa libreria, apri la finestra Package Manager Console, quindi digita il seguente comando e premi il tasto Invio per installare la libreria AutoMapper nel tuo progetto:
PM> Install-Package AutoMapper
Dopo aver installato AutoMapper libreria, quindi aggiungerà un riferimento alla dll di AutoMapper che puoi trovare nella sezione dei riferimenti del progetto come mostrato nell'immagine sottostante.
Una volta installato Automapper nel tuo progetto, puoi usarlo in molti modi diversi. Discuteremo tutte queste opzioni in un articolo successivo. In questo articolo, discuterò alcuni semplici esempi per farti capire esattamente come funziona AutoMapper in un progetto.
Lavoreremo con lo stesso esempio, ovvero mappare l'oggetto dipendente con l'oggetto EmployeeDTO ma qui useremo AutoMapper .
Fase 2:inizializzazione o configurazione di AutoMapper
Una volta che hai definito i tuoi tipi (cioè le classi), puoi creare un mapper per i due tipi usando il costruttore della classe MapperConfiguration. Puoi creare una sola istanza MapperConfiguration per AppDomain e dovrebbe essere istanziato durante l'avvio dell'applicazione. La sintassi per creare l'istanza MapperConfiguration è riportata di seguito.
Il tipo a sinistra è il tipo di origine, ad esempio TSource , nel nostro esempio, andrà a Oggetto dipendente e il tipo a destra è il tipo di destinazione, ad esempio TDestation , nel nostro esempio, andrà all'oggetto EmployeeDTO . Quindi, due mappe del Dipendente con EmployeeDTO , è necessario creare la configurazione del mappatore come mostrato di seguito.
Utilizzo di AutoMapper:
L'immagine seguente mostra come inizializzare e utilizzare automapper in C#.
Di seguito è riportato il codice completo
using System;
using AutoMapper;
namespace AutoMapperDemo
{
class Program
{
static void Main(string[] args)
{
//Initialize the mapper
var config = new MapperConfiguration(cfg =>
cfg.CreateMap<Employee, EmployeeDTO>()
);
//Creating the source object
Employee emp = new Employee
{
Name = "James",
Salary = 20000,
Address = "London",
Department = "IT"
};
//Using automapper
var mapper = new Mapper(config);
var empDTO = mapper.Map<EmployeeDTO>(emp);
//OR
//var empDTO2 = mapper.Map<Employee, EmployeeDTO>(emp);
Console.WriteLine("Name:" + empDTO.Name + ", Salary:" + empDTO.Salary + ", Address:" + empDTO.Address + ", Department:" + empDTO.Department);
Console.ReadLine();
}
}
public class Employee
{
public string Name { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Department { get; set; }
}
public class EmployeeDTO
{
public string Name { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Department { get; set; }
}
}
Quando esegui l'applicazione, i dati verranno visualizzati come previsto.
Cosa accadrà se i nomi delle proprietà di origine e di destinazione sono diversi?
Diamo un'occhiata alla modifica del nome della proprietà dell'oggetto di origine e di destinazione. Cambiamo il EmployeeDTO classe Nome e Dipartimento proprietà a FullName e Reparto ed esegui l'applicazione e guarda cosa è successo.
Di seguito è riportato l'esempio completo.
using System;
using AutoMapper;
namespace AutoMapperDemo
{
class Program
{
static void Main(string[] args)
{
//Initialize the mapper
var config = new MapperConfiguration(cfg =>
cfg.CreateMap<Employee, EmployeeDTO>()
);
//Creating the source object
Employee emp = new Employee
{
Name = "James",
Salary = 20000,
Address = "London",
Department = "IT"
};
//Using automapper
var mapper = new Mapper(config);
var empDTO = mapper.Map<EmployeeDTO>(emp);
//OR
//var empDTO2 = mapper.Map<Employee, EmployeeDTO>(emp);
Console.WriteLine("Name:" + empDTO.FullName + ", Salary:" + empDTO.Salary + ", Address:" + empDTO.Address + ", Department:" + empDTO.Dept);
Console.ReadLine();
}
}
public class Employee
{
public string Name { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Department { get; set; }
}
public class EmployeeDTO
{
public string FullName { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Dept { get; set; }
}
}
Con le modifiche precedenti in atto, ora se esegui l'applicazione, dovresti ottenere il seguente output.
Dall'output sopra, mostra chiaramente che il Nome e Dipartimento sono vuoti, il che significa che queste due proprietà non sono mappate dal tipo di origine al tipo di destinazione.
Nota: Quando i nomi delle proprietà sono diversi nei tipi di origine e di destinazione, per impostazione predefinita l'Automapper C# non eseguirà il mapping di tali proprietà
Come mappare due proprietà quando i nomi sono diversi usando automapper?
La risposta è utilizzando ForMember opzione. Quindi, alla Mappa il Nome proprietà con il FullName proprietà e il Dipartimento proprietà con il Reparto proprietà, è necessario mappare queste due proprietà nella configurazione della mappatura come mostrato di seguito.
Nota: Discuteremo il ForMember e Mappa opzioni in dettaglio nei nostri prossimi articoli.
Di seguito è riportato il codice completo.
using System;
using AutoMapper;
namespace AutoMapperDemo
{
class Program
{
static void Main(string[] args)
{
//Initialize the mapper
var config = new MapperConfiguration(cfg =>
cfg.CreateMap<Employee, EmployeeDTO>()
.ForMember(dest => dest.FullName, act => act.MapFrom(src => src.Name))
.ForMember(dest => dest.Dept, act => act.MapFrom(src => src.Department))
);
//Creating the source object
Employee emp = new Employee
{
Name = "James",
Salary = 20000,
Address = "London",
Department = "IT"
};
//Using automapper
var mapper = new Mapper(config);
var empDTO = mapper.Map<EmployeeDTO>(emp);
//OR
//var empDTO2 = mapper.Map<Employee, EmployeeDTO>(emp);
Console.WriteLine("Name:" + empDTO.FullName + ", Salary:" + empDTO.Salary + ", Address:" + empDTO.Address + ", Department:" + empDTO.Dept);
Console.ReadLine();
}
}
public class Employee
{
public string Name { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Department { get; set; }
}
public class EmployeeDTO
{
public string FullName { get; set; }
public int Salary { get; set; }
public string Address { get; set; }
public string Dept { get; set; }
}
}
Ora esegui l'applicazione e dovresti vedere l'output come previsto.
Nel prossimo articolo parlerò di Automapper Complex Mapping in C# con esempi. In questo articolo, provo a spiegare AutoMapper in C# con esempi. Spero che questo articolo ti piaccia.