Automapper est une bibliothèque polyvalente et puissante en C# conçue pour faciliter le mapping objet-à-objet, rendant le transfert de données entre des modèles d'objets complexes plus facile et plus maintenable. Dans cet article, nous explorerons comment Automapper peut efficacement mapper les propriétés, aplatir les modèles d'objets complexes et travailler avec divers types d'objets comme les objets du domaine utilisateur et les objets de transfert de données.

Introduction à Automapper

Automapper en C# est un mappeur objet-objet, un outil qui simplifie la conversion et le transfert de données entre différents types d'objets. Cela est particulièrement utile dans les scénarios impliquant des entités de données et leur transformation en objets de transfert de données (DTOs).

Caractéristiques clés d'Automapper

• Simplification du code : Automapper réduit considérablement le besoin de code manuel en automatisant le mappage des propriétés, évitant ainsi les erreurs et permettant un gain de temps.
• Flexibilité des configurations de cartographie : Automapper permet une personnalisation détaillée des configurations de cartographie, s'adaptant ainsi à un large éventail de scénarios de cartographie.
• Performances optimales : La bibliothèque est conçue pour gérer des modèles d'objets volumineux et complexes sans surcharge de performance significative.

Prise en main d'Automapper

Pour utiliser Automapper, il doit d'abord être installé via la console du Package Manager, un composant de l'environnement de développement qui facilite la gestion des paquets logiciels.

Installation via la console du Package Manager

Vous pouvez facilement installer Automapper dans votre projet en exécutant une simple commande dans votre console du Package Manager :

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

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 mappage est créée pour mapper les propriétés de SourceClass à DestinationClass.
• Une instance de IMapper est ensuite créée en utilisant cette configuration.

Techniques de mapping avancées avec Automapper

Les capacités d'Automapper s'étendent bien au-delà du simple mapping propriété à propriété. Il peut habilement gérer des scénarios plus complexes.

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.

Exemples d'utilisation pratique

Pour mieux comprendre l'utilité d'Automapper, explorons quelques exemples pratiques.

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)

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 mappage entre User et UserDTO où 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)

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 mappage 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 des 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.

Aperçu de Iron Software Suite

La Iron Software Suite for .NET est un package robuste avec une série de bibliothèques, chacune servant un but spécifique. Il couvre des fonctionnalités telles que la création, la lecture et l'édition de PDFs, la conversion de HTML en PDF, et le traitement d'images en texte dans plusieurs langues. Cette suite répond à divers besoins de développement, en faisant un ajout polyvalent à tout projet C#.

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 mappage des 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 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.

Conclusion

Automapper est un outil inestimable pour les développeurs C#, rationalisant la tâche du mapping entre objets. Ses robustes capacités de mapping de propriétés, de gestion de modèles d'objets complexes, et d'offrir des configurations de mapping personnalisables en font un outil essentiel pour un développement logiciel efficace. Comprendre les subtilités des modèles d'objets et comment Automapper peut être configuré pour répondre à des besoins spécifiques est crucial pour maximiser son potentiel dans tout projet.

La Iron Suite d'Iron Software offre diverses options de licence, y compris un essai gratuit de Iron Software, pour répondre aux différents besoins de projet. Ses licences sont réparties en Lite, Plus, et Professionnel, répondant à différentes tailles d'équipes et offrant des fonctionnalités de support complètes. Intégrer cette suite avec Automapper peut grandement améliorer les projets C#, ajoutant des capacités de traitement de données et de manipulation de documents.