Automapper C# (Comment ça fonctionne pour les développeurs)

Caractéristiques clés d'Automapper

• Simplification du code : Automapper réduit drastiquement la nécessité de code manuel en automatisant le mapping des propriétés, prévenant ainsi les erreurs et économisant du temps.
• Flexibilité dans les configurations de mapping : Automapper permet une personnalisation détaillée des configurations de mapping, accommodant une large gamme de scénarios de mapping.
• Efficacité des performances : La bibliothèque est conçue pour gérer de grands et complexes modèles d'objets sans surcharge de performance significative.

Installation via la console du gestionnaire de paquets

Vous pouvez facilement installer Automapper dans votre projet en exécutant une simple commande dans votre console du gestionnaire de paquets :

Install-Package AutoMapper

Configurer la configuration de mapping de base

La première étape dans l'utilisation d'Automapper est de définir la configuration du mapping. Cela implique de spécifier comment les propriétés de l'objet d'entrée (source) doivent être transférées vers l'objet de sortie (destination).

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()

• Dans l'exemple ci-dessus, une configuration de mapping est créée pour mapper les propriétés de SourceClass à DestinationClass.
• Une instance de IMapper est ensuite créée en utilisant cette configuration.

Aplatir les modèles d'objets complexes

L'une des forces d'Automapper est sa capacité à aplatir les modèles d'objets complexes. Cette fonctionnalité est particulièrement utile lorsqu'il s'agit d'objets imbriqués, permettant le mapping de ces propriétés imbriquées vers une structure de classe de destination plate.

Gestion polyvalente des types d'objets

Automapper peut efficacement mapper entre divers types d'objets, y compris les objets de domaine utilisateur, les DTOs, et même les modèles de vue, offrant une solution polyvalente pour différents besoins de transfert de données.

Exemple 1 : Mapping simple

Considérons un scénario où nous devons mapper des propriétés d'une entité utilisateur à un DTO utilisateur :

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)

• Cet exemple illustre le mapping entre User et UserDTO où le FullName dans UserDTO est une concaténation de FirstName et LastName de User.

Exemple 2 : Mapping avancé avec des objets complexes

Dans un scénario plus complexe, mappons un objet de commande avec des détails utilisateur imbriqués à un DTO de commande simplifié :

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)

• Cet exemple démontre le mapping d'un objet Order, contenant des détails imbriqués OrderedBy, vers un OrderDTO plat, extrayant et combinant les noms d'utilisateur en une seule propriété FullName.

Avec la version 9.0, AutoMapper est passé d'une API statique (Mapper.Initialize) à une API basée sur les instances. Ce changement améliore la flexibilité et est plus adapté aux applications modernes, en particulier celles utilisant l'injection de dépendances. Si vous travaillez avec des versions antérieures à 9.0, l'approche API statique est applicable. Cependant, pour les versions plus récentes, il est recommandé d'adopter l'API basée sur les instances comme indiqué dans les exemples ci-dessus.

Principaux composants de Iron Software Suite

1. IronPDF pour la gestion de PDF : Ce composant permet aux développeurs de créer, lire, éditer et signer des PDFs. Il offre également la capacité de convertir HTML en PDF, une fonctionnalité qui peut être particulièrement utile dans la génération de rapports ou de documentation à partir de données basées sur le web.

2. IronXL Manipulation de fichiers Excel : IronXL facilite le travail avec les fichiers Excel sans avoir besoin d'Office Interop, rationalisant les tâches de manipulation et d'analyse des données.

3. IronOCR pour l'extraction de texte : Il permet l'extraction de texte à partir d'images, prenant en charge un éventail diversifié de 125 langues, le rendant donc très polyvalent pour les projets internationaux.

4. IronBarcode pour le support QR et Code-barres : Une bibliothèque qui permet la lecture et l'écriture de codes QR et de codes-barres, renforçant les capacités de gestion des stocks, de suivi, et d'autres tâches connexes.

Complémentarité avec Automapper

Alors que Automapper excelle dans le mapping de propriétés entre différents modèles d'objets en C#, les bibliothèques d'Iron Software étendent la fonctionnalité en offrant des outils pour gérer divers formats et types de données. Par exemple, après avoir utilisé Automapper pour transformer un objet de domaine utilisateur en un DTO, IronPDF pourrait être utilisé pour générer un rapport complet au format PDF. De même, les données extraites ou transformées à l'aide d'Automapper pourraient être davantage manipulées ou analysées en utilisant IronXL pour les opérations sur les fichiers Excel.