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

Automapper est une bibliothèque polyvalente et puissante en C# conçue pour faciliter le mappage d'objet à objet, ce qui rend le transfert de données entre des modèles d'objets complexes plus facile et plus facile à maintenir. Dans cet article, nous allons explorer comment Automapper peut efficacement mapper des propriétés, aplatir des modèles d'objets complexes et travailler avec différents types d'objets tels que les objets du domaine utilisateur et les objets de transfert de données.

Introduction à l'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. Ceci est particulièrement utile dans des scénarios impliquant des entités de données et leur transformation en objets de transfert de données (DTOs).

Principales caractéristiques d'Automapper

Simplification du code : Automapper réduit considérablement le besoin de code manuel en automatisant la correspondance des propriétés, ce qui prévient les erreurs et fait gagner du temps.

Flexibilité dans les configurations de mappage : Automapper permet une personnalisation détaillée des configurations de mappage, s'adaptant à une large gamme de scénarios de mappage.

Efficacité de performance : La bibliothèque est conçue pour gérer de grands et complexes modèles d'objets sans surcharge de performance significative.

Premiers pas avec Automapper

Pour utiliser Automapper, il faut d'abord l'installer via la console du gestionnaire de paquets, un composant de l'environnement de développement qui facilite la gestion des paquets de logiciels.

Installation via la console du gestionnaire de paquets

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

Install-Package IronPdf

Configuration du mappage de base

L'étape fondamentale de l'utilisation d'Automapper consiste à définir la configuration du mappage. Cela implique de spécifier comment les propriétés de l'objet d'entrée (source) doivent être transférées à 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()

Techniques avancées de cartographie avec Automapper

Les capacités d'Automapper vont bien au-delà de la simple mise en correspondance de biens immobiliers. Il peut gérer habilement des scénarios plus complexes.

Aplatir des modèles d'objets complexes

L'une des forces d'Automapper est sa capacité à aplatir des modèles d'objets complexes. Cette fonction est particulièrement utile lorsqu'il s'agit d'objets imbriqués, car elle permet de faire correspondre ces propriétés imbriquées à une structure de classe de destination plate.

Traitement polyvalent des types d'objets

Automapper peut établir des correspondances entre différents types d'objets, y compris les objets du domaine de l'utilisateur, les DTO et même les modèles de vue, offrant ainsi une solution polyvalente pour les différents besoins en matière de transfert de données.

Exemples d'utilisation pratique

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

Exemple 1 : Cartographie simple

Prenons l'exemple d'un scénario dans lequel nous devons faire correspondre 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();

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

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

Exemple 2 : Cartographie avancée avec des objets complexes

Dans un scénario plus complexe, mappons un objet de commande avec des détails d'utilisateur imbriqués dans 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();

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

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

Avec la version 9.0, AutoMapper est passé d'une API statique (Mapper.Initialize) à une API basée sur des instances. Cette modification améliore la flexibilité et convient mieux aux applications modernes, en particulier celles qui utilisent l'injection de dépendances. Si vous travaillez avec des versions antérieures à la 9.0, l'approche statique de l'API est applicable. Toutefois, 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.

Vue d'ensemble de la Iron Software Suite

La suite Iron Software pour .NET est un package robuste comprenant une série de bibliothèques, chacune servant un objectif spécifique. Il couvre des fonctionnalités telles que la création, la lecture et l'édition de PDF, la conversion de HTML en PDF et la transformation d'images en texte dans plusieurs langues. Cette suite répond à divers besoins de développement, ce qui en fait un complément polyvalent à tout projet C#.

Principaux éléments de la Iron Software Suite

1. IronPDF pour la gestion des PDF : Ce composant permet aux développeurs de créer, lire, éditer et signer des PDF. Il offre également la possibilité de convertir HTML en PDF, une fonction qui peut s'avérer particulièrement utile pour générer des rapports ou de la documentation à partir de données basées sur le web.

   

2. Gestion de fichiers Excel avec IronXL : IronXL facilite le travail avec les fichiers Excel sans nécessiter Office Interop, simplifiant les tâches de manipulation et d'analyse de données.

   

3. IronOCR pour l'Extraction de Texte : Il permet l'extraction de texte à partir d'images, prenant en charge un large éventail de 127 langues, ce qui le rend très polyvalent pour les projets internationaux.

   

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

   

Complémentarité avec l'Automapper

Bien 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 traiter 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 manipulées ou analysées plus avant à l'aide d'IronXL pour les opérations sur les fichiers Excel.

Conclusion

Automapper est un outil inestimable pour les développeurs C#, simplifiant la tâche de mappage entre les objets. Ses solides capacités en matière de mappage des propriétés, de gestion de modèles d'objets complexes et de configurations de mappage personnalisables en font un outil essentiel pour un développement logiciel efficace. Il est essentiel de comprendre les subtilités des modèles d'objets et la manière dont Automapper peut être configuré pour répondre à des besoins spécifiques afin de maximiser son potentiel dans n'importe quel projet.

L'Iron Suite de Iron Software propose diverses options de licence, y compris une version d'essai gratuite d'Iron Software, pour répondre aux différents besoins de projet. Les licences sont échelonnées en Lite, Plus et Professional, ce qui permet de répondre aux besoins d'équipes de différentes tailles et d'offrir des fonctions d'assistance complètes. L'intégration de cette suite avec Automapper permet d'améliorer considérablement les projets C#, en ajoutant des capacités de traitement de données et de manipulation de documents.