Automapper C# (Cómo funciona para desarrolladores)

Características principales de Automapper

• Simplificación de código: Automapper reduce drásticamente la necesidad de código manual al automatizar el mapeo de propiedades, evitando así errores y ahorrando tiempo.
• Flexibilidad en las configuraciones de mapeo: Automapper permite una personalización detallada de las configuraciones de mapeo, adaptándose a una amplia gama de escenarios de mapeo.
• Eficiencia de rendimiento: la biblioteca está diseñada para manejar modelos de objetos grandes y complejos sin una sobrecarga de rendimiento significativa.

Instalación a través de la consola del gestor de paquetes

Puede instalar Automapper en su proyecto ejecutando el siguiente comando en la consola del administrador de paquetes:

Install-Package AutoMapper

Cómo establecer la configuración básica del mapeo

El paso fundamental para usar Automapper es definir la configuración de mapeo. Esto implica especificar cómo las propiedades del objeto de entrada (fuente) deben transferirse al objeto de salida (destino).

var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<SourceClass, DestinationClass>();
});
IMapper mapper = config.CreateMapper();

var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<SourceClass, DestinationClass>();
});
IMapper mapper = config.CreateMapper();

Dim config = New MapperConfiguration(Sub(cfg)
	cfg.CreateMap(Of SourceClass, DestinationClass)()
End Sub)
Dim mapper As IMapper = config.CreateMapper()

• En el ejemplo anterior, se crea una configuración de mapeo para mapear propiedades de SourceClass a DestinationClass.
• Luego se crea una instancia de IMapper usando esta configuración.

Aplanación de modelos de objetos complejos

Una de las fortalezas de Automapper es su capacidad para aplanar modelos de objetos complejos. Esta característica es especialmente útil cuando se trata de objetos anidados, permitiendo el mapeo de estas propiedades anidadas a una estructura de clase de destino plana.

Manejo versátil de tipos de objetos

Automapper puede mapear de manera competente entre varios tipos de objetos, incluidos objetos de dominio de usuario, DTOs, e incluso modelos de vista, proporcionando una solución versátil para diferentes necesidades de transferencia de datos.

Ejemplo 1: Mapeo simple

Considera un escenario donde necesitamos mapear propiedades de una entidad de usuario a un DTO de usuario:

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

public class UserDTO
{
    public string FullName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<User, UserDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.FirstName + " " + src.LastName));
});
IMapper mapper = config.CreateMapper();
User user = new User { FirstName = "John", LastName = "Doe", Address = "123 Street", City = "CityName" };
UserDTO userDto = mapper.Map<UserDTO>(user);

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

public class UserDTO
{
    public string FullName { get; set; }
    public string Address { get; set; }
    public string City { get; set; }
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<User, UserDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.FirstName + " " + src.LastName));
});
IMapper mapper = config.CreateMapper();
User user = new User { FirstName = "John", LastName = "Doe", Address = "123 Street", City = "CityName" };
UserDTO userDto = mapper.Map<UserDTO>(user);

Public Class User
	Public Property FirstName() As String
	Public Property LastName() As String
	Public Property Address() As String
	Public Property City() As String
End Class

Public Class UserDTO
	Public Property FullName() As String
	Public Property Address() As String
	Public Property City() As String
End Class

' Mapping Configuration
Private config = New MapperConfiguration(Sub(cfg)
	cfg.CreateMap(Of User, UserDTO)().ForMember(Function(dest) dest.FullName, Function(opt) opt.MapFrom(Function(src) src.FirstName & " " & src.LastName))
End Sub)
Private mapper As IMapper = config.CreateMapper()
Private user As New User With {
	.FirstName = "John",
	.LastName = "Doe",
	.Address = "123 Street",
	.City = "CityName"
}
Private userDto As UserDTO = mapper.Map(Of UserDTO)(user)

• Este ejemplo muestra la asignación entre User y UserDTO donde FullName en UserDTO es una concatenación de FirstName y LastName de User.

Ejemplo 2: Mapeo avanzado con objetos complejos

En un escenario más complejo, mapeemos un objeto de pedido con detalles de usuario anidados a un DTO de pedido simplificado:

public class Order
{
    public User OrderedBy { get; set; }
    // Other properties...
}

public class OrderDTO
{
    public string FullName { get; set; }
    // Other properties...
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Order, OrderDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.OrderedBy.FirstName + " " + src.OrderedBy.LastName));
});
IMapper mapper = config.CreateMapper();
Order order = new Order { OrderedBy = new User { FirstName = "Jane", LastName = "Doe" } };
OrderDTO orderDto = mapper.Map<OrderDTO>(order);

public class Order
{
    public User OrderedBy { get; set; }
    // Other properties...
}

public class OrderDTO
{
    public string FullName { get; set; }
    // Other properties...
}

// Mapping Configuration
var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Order, OrderDTO>()
       .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => src.OrderedBy.FirstName + " " + src.OrderedBy.LastName));
});
IMapper mapper = config.CreateMapper();
Order order = new Order { OrderedBy = new User { FirstName = "Jane", LastName = "Doe" } };
OrderDTO orderDto = mapper.Map<OrderDTO>(order);

Public Class Order
	Public Property OrderedBy() As User
	' Other properties...
End Class

Public Class OrderDTO
	Public Property FullName() As String
	' Other properties...
End Class

' Mapping Configuration
Private config = New MapperConfiguration(Sub(cfg)
	cfg.CreateMap(Of Order, OrderDTO)().ForMember(Function(dest) dest.FullName, Function(opt) opt.MapFrom(Function(src) src.OrderedBy.FirstName & " " & src.OrderedBy.LastName))
End Sub)
Private mapper As IMapper = config.CreateMapper()
Private order As New Order With {
	.OrderedBy = New User With {
		.FirstName = "Jane",
		.LastName = "Doe"
	}
}
Private orderDto As OrderDTO = mapper.Map(Of OrderDTO)(order)

• Este ejemplo demuestra la asignación de un objeto Order, que contiene detalles OrderedBy anidados, a un OrderDTO plano, extrayendo y combinando nombres de usuario en una única propiedad FullName.

Con la versión 9.0, AutoMapper ha pasado de ser una API estática (Mapper.Initialize) a una API basada en instancias. Este cambio mejora la flexibilidad y es más adecuado para aplicaciones modernas, especialmente aquellas que utilizan inyección de dependencias. Para versiones anteriores a la 9.0, el enfoque de API estática es aplicable. Sin embargo, para las versiones más recientes, se recomienda adoptar la API basada en instancias como se describe en los ejemplos anteriores.

Componentes clave de Iron Software Suite

1. IronPDF para Gestión de PDFs: Este componente permite a los desarrolladores crear, leer, editar y firmar PDFs. También ofrece la capacidad de convertir HTML a PDF, una característica que puede ser particularmente útil en la generación de informes o documentación a partir de datos basados en la web.

   

2. IronXL Manejo de Archivos de Excel: IronXL facilita el trabajo con archivos Excel sin necesidad de Office Interop, simplificando las tareas de manipulación y análisis de datos.

   

3. IronOCR para Extracción de Texto: Permite la extracción de texto de imágenes, soportando una diversidad de 125 idiomas, haciéndolo altamente versátil para proyectos internacionales.

   

4. IronBarcode para Soporte de Códigos QR y Barras: Una biblioteca que permite leer y escribir códigos QR y códigos de barras, mejorando las capacidades para la gestión de inventarios, seguimiento y otras tareas relacionadas.

Complementariedad con Automapper

Si bien Automapper destaca en la asignación de propiedades entre diferentes modelos de objetos en C#, las bibliotecas de Iron Software amplían la funcionalidad ofreciendo herramientas para gestionar diversos formatos y tipos de datos. Por ejemplo, tras usar Automapper para transformar un objeto de dominio de usuario en un DTO, IronPDF podría utilizarse para generar un informe completo en formato PDF. De manera similar, los datos extraídos o transformados usando Automapper podrían ser manipulados o analizados más a fondo usando IronXL para operaciones de archivos Excel.