Automapper C# (Wie es für Entwickler funktioniert)

Hauptmerkmale von Automapper

• Vereinfachung des Codes: Automapper reduziert den Bedarf an manuellem Code drastisch, indem es die Zuordnung von Eigenschaften automatisiert und so Fehler vermeidet und Zeit spart.
• Flexibilität bei den Kartenkonfigurationen: Automapper ermöglicht die detaillierte Anpassung der Kartenkonfigurationen und deckt so ein breites Spektrum an Kartenszenarien ab.
• Leistungseffizienz: Die Bibliothek ist so konzipiert, dass sie große und komplexe Objektmodelle ohne signifikanten Leistungsverlust verarbeiten kann.

Installation über die Paketmanager-Konsole

Sie können Automapper in Ihrem Projekt ganz einfach installieren, indem Sie einen einfachen Befehl in Ihrer Paketmanager-Konsole ausführen:

Install-Package AutoMapper

Einrichten der grundlegenden Mapping-Konfiguration

Der grundlegende Schritt bei der Verwendung von Automapper besteht darin, die Mapping-Konfiguration zu definieren. Dies beinhaltet die Spezifizierung, wie die Eingabeobjekteigenschaften (Quelle) auf die Ausgabeobjekteigenschaften (Ziel) übertragen werden sollen.

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

• Im obigen Beispiel wird eine Mapping-Konfiguration erstellt, um Eigenschaften von SourceClass auf DestinationClass abzubilden.
• Anschließend wird mit dieser Konfiguration eine Instanz von IMapper erstellt.

Komplexe Objektmodelle abflachen

Eine der Stärken von Automapper besteht in seiner Fähigkeit, komplexe Objektmodelle zu flatten. Diese Funktion ist besonders nützlich beim Umgang mit verschachtelten Objekten und ermöglicht die Zuordnung dieser verschachtelten Eigenschaften zu einer flachen Zielklassenstruktur.

Vielseitige Objekttypverarbeitung

Automapper kann verschiedene Objekttypen effizient abbilden, einschließlich Benutzerdomänenobjekten, DTOs und sogar View-Modellen, und bietet somit eine vielseitige Lösung für unterschiedliche Datenübertragungsbedürfnisse.

Beispiel 1: Einfaches Mapping

Betrachten Sie ein Szenario, in dem wir Eigenschaften von einer Benutzerentität auf ein Benutzer-DTO abbilden müssen:

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)

Dieses Beispiel veranschaulicht die Zuordnung zwischen User und UserDTO, wobei FullName in UserDTO eine Verkettung von FirstName und LastName aus User ist.

Beispiel 2: Fortgeschrittenes Mapping mit komplexen Objekten

In einem komplexeren Szenario lassen Sie uns ein Bestellobjekt mit verschachtelten Benutzerdetails auf ein vereinfachtes Order-DTO abbilden:

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)

Dieses Beispiel veranschaulicht die Abbildung von einem Order-Objekt, das verschachtelte OrderedBy-Details enthält, auf ein flaches OrderDTO-Objekt, wobei Benutzernamen extrahiert und zu einer einzigen FullName-Eigenschaft kombiniert werden.

Mit Version 9.0 hat AutoMapper den Übergang von einer statischen API (Mapper.Initialize) zu einer instanzbasierten API vollzogen. Diese Änderung verbessert die Flexibilität und ist besser geeignet für moderne Anwendungen, insbesondere solche, die Dependency Injection verwenden. Wenn Sie mit älteren Versionen als 9.0 arbeiten, ist der statische API-Ansatz anwendbar. Für neuere Versionen wird jedoch empfohlen, die instanzbasierte API, wie in den oben genannten Beispielen beschrieben, zu übernehmen.

Schlüsselkomponenten der Iron Software Suite

1. IronPDF für PDF-Management: Diese Komponente ermöglicht es Entwicklern, PDFs zu erstellen, zu lesen, zu bearbeiten und zu signieren. Es bietet auch die Möglichkeit, HTML in PDF umzuwandeln, was besonders nützlich sein kann, um Berichte oder Dokumentationen aus webbasierter Daten zu erstellen.

   

2. IronXL Excel-Dateibehandlung: IronXL erleichtert die Arbeit mit Excel-Dateien, ohne dass Office Interop erforderlich ist, und rationalisiert somit Aufgaben der Datenmanipulation und -analyse.

   

3. IronOCR für Textextraktion: Es ermöglicht die Textextraktion aus Bildern und unterstützt eine vielfältige Palette von 125 Sprachen, was es besonders vielseitig für internationale Projekte macht.

   

4. IronBarcode für QR- und Barcodesupport: Eine Bibliothek, die das Lesen und Schreiben von QR-Codes und Barcodes ermöglicht und die Fähigkeiten für Bestandsmanagement, Verfolgung und andere verwandte Aufgaben erweitert.

Komplementarität mit Automapper

Während Automapper sich durch die Abbildung von Eigenschaften zwischen verschiedenen Objektmodellen in C# auszeichnet, erweitern die Bibliotheken von Iron Software die Funktionalität durch Werkzeuge zur Verarbeitung verschiedener Datenformate und -typen. Beispielsweise kann nach der Transformation eines Benutzerdomänenobjekts in ein DTO mithilfe von Automapper IronPDF verwendet werden, um einen umfassenden Bericht im PDF-Format zu generieren. Ähnlich könnte Daten, die mit Automapper extrahiert oder transformiert wurden, weiter manipuliert oder mit IronXL für Excel-Dateioperationen analysiert werden.