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

Automapper ist eine vielseitige und leistungsstarke Bibliothek in C#, die das Objekt-zu-Objekt-Mapping erleichtert und die Übertragung von Daten zwischen komplexen Objektmodellen einfacher und wartbarer macht. In diesem Artikel werden wir untersuchen, wie Automapper Eigenschaften effizient zuordnen, komplexe Objektmodelle reduzieren und mit verschiedenen Objekttypen wie Benutzerdomänenobjekten und Datenübertragungsobjekten arbeiten kann.

Einführung in Automapper

Automapper in C# ist ein Objekt-Objekt-Mapper, ein Werkzeug, das die Konvertierung und Übertragung von Daten zwischen verschiedenen Objekttypen vereinfacht. Dies ist besonders nützlich in Szenarien, die Datenentitäten und deren Umwandlung in Datenübertragungsobjekte betreffen (DTOs).

Hauptmerkmale von Automapper

Vereinfachung des Codes: Automapper reduziert den Bedarf an manuellem Code drastisch, indem es die Zuordnung von Eigenschaften automatisiert und so Fehler verhindert und Zeit spart.

Flexibilität bei Mapping-Konfigurationen: Automapper ermöglicht eine detaillierte Anpassung der Mapping-Konfigurationen, so dass ein breites Spektrum an Mapping-Szenarien möglich ist.

Performance-Effizienz: Die Bibliothek ist so konzipiert, dass sie große und komplexe Objektmodelle ohne nennenswerten Performance-Overhead verarbeiten kann.

Erste Schritte mit Automapper

Um Automapper nutzen zu können, muss er zunächst über die Paketmanager-Konsole installiert werden, eine Komponente der Entwicklungsumgebung, die die Verwaltung von Softwarepaketen erleichtert.

Installation über die Paketmanager-Konsole

Sie können Automapper ganz einfach in Ihrem Projekt installieren, indem Sie einen einfachen Befehl in der Konsole Ihres Paketmanagers ausführen:

Install-Package IronPdf

Einrichten der grundlegenden Mapping-Konfiguration

Der grundlegende Schritt bei der Verwendung von Automapper besteht darin, die Mapping-Konfiguration zu definieren. Dabei wird festgelegt, wie das Eingabeobjekt (quelle) eigenschaften an das Ausgabeobjekt übertragen werden sollen (zielort).

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

Erweiterte Mapping-Techniken mit Automapper

Die Möglichkeiten von Automapper gehen weit über die einfache Zuordnung von Eigenschaften zu Eigenschaften hinaus. Es kann auch kompliziertere Szenarien bewältigen.

Abflachung komplexer Objektmodelle

Eine der Stärken von Automapper ist seine Fähigkeit, komplexe Objektmodelle zu reduzieren. Diese Funktion ist besonders nützlich, wenn es um verschachtelte Objekte geht, da sie die Zuordnung dieser verschachtelten Eigenschaften zu einer flachen Zielklassenstruktur ermöglicht.

Vielseitige Handhabung von Objekttypen

Automapper ist in der Lage, verschiedene Objekttypen zuzuordnen, einschließlich Benutzerdomänenobjekten, DTOs und sogar Ansichtsmodellen, und bietet somit eine vielseitige Lösung für unterschiedliche Datentransferanforderungen.

Praktische Anwendungsbeispiele

Um den Nutzen von Automapper besser zu verstehen, lassen Sie uns einige praktische Beispiele untersuchen.

Beispiel 1: Einfaches Mapping

Stellen Sie sich ein Szenario vor, in dem wir Eigenschaften von einer Benutzerentität einem Benutzer-DTO zuordnen 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();

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

Beispiel 2: Fortgeschrittenes Mapping mit komplexen Objekten

In einem komplexeren Szenario wollen wir ein Auftragsobjekt mit verschachtelten Benutzerdetails einem vereinfachten Auftrags-DTO zuordnen:

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

Mit Version 9.0 ist AutoMapper von einer statischen API (mapper.Initialize) zu einer instanzbasierten API. Diese Änderung erhöht die Flexibilität und eignet sich besser für moderne Anwendungen, insbesondere für 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 obigen Beispielen beschrieben zu verwenden.

Überblick über die Iron Software Suite

Die Iron Software Suite (Iron Suite) für .NET ist ein robustes Paket mit einer Reihe von Bibliotheken, die jeweils einem bestimmten Zweck dienen. Es umfasst Funktionen wie das Erstellen, Lesen und Bearbeiten von PDFs, die Konvertierung von HTML in PDF und die Verarbeitung von Bildern in Text in mehreren Sprachen. Diese Suite deckt verschiedene Entwicklungsbedürfnisse ab und ist damit eine vielseitige Ergänzung für jedes C#-Projekt.

Hauptkomponenten der Iron Software Suite

1. IronPDF: Mit dieser Komponente können Entwickler PDFs erstellen, lesen, bearbeiten und unterschreiben. Es bietet auch die Möglichkeit, HTML in PDF zu konvertieren, eine Funktion, die besonders bei der Erstellung von Berichten oder Dokumentationen aus webbasierten Daten nützlich sein kann.

   

2. IronXL: IronXL erleichtert die Arbeit mit Excel-Dateien, ohne dass Office Interop erforderlich ist, und vereinfacht die Datenmanipulation und -analyse.

   

3. IronOCR: Es ermöglicht die Textextraktion aus Bildern und unterstützt eine Vielzahl von 127 Sprachen, was es für internationale Projekte sehr vielseitig macht.

   

4. IronBarcode: Eine Bibliothek, die das Lesen und Schreiben von QR-Codes und Barcodes ermöglicht und so die Möglichkeiten für die Bestandsverwaltung, die Nachverfolgung und andere verwandte Aufgaben erweitert.

   

Komplementarität mit Automapper

Während Automapper sich durch die Abbildung von Eigenschaften zwischen verschiedenen Objektmodellen in C# auszeichnet, Iron Suite erweitert die Funktionalität, indem es Werkzeuge für die Verarbeitung verschiedener Datenformate und -typen anbietet. Nach der Verwendung von Automapper zur Umwandlung eines Benutzerdomänenobjekts in ein DTO kann IronPDF zum Beispiel verwendet werden, um einen umfassenden Bericht im PDF-Format zu erstellen. Ebenso können Daten, die mit Automapper extrahiert oder transformiert wurden, mit IronXL for Excel file operations weiter bearbeitet oder analysiert werden.

Schlussfolgerung

Automapper ist ein unschätzbares Werkzeug für C#-Entwickler, das die Aufgabe des Mappings zwischen Objekten vereinfacht. Seine robusten Fähigkeiten beim Mapping von Eigenschaften, bei der Handhabung komplexer Objektmodelle und bei der Bereitstellung anpassbarer Mapping-Konfigurationen machen es zu einem unverzichtbaren Werkzeug für eine effiziente Softwareentwicklung. Das Verständnis der Feinheiten von Objektmodellen und der Konfiguration von Automapper zur Anpassung an spezifische Anforderungen ist entscheidend für die Maximierung des Potenzials in jedem Projekt.

Die Iron Software's Iron Suite bietet verschiedene Lizenzierungsoptionen, darunter eine kostenloser Testum unterschiedlichen Projektanforderungen gerecht zu werden. Die Lizenzen sind in Lite, Plus und Professional gestaffelt, beginnend mit $749, die für verschiedene Teamgrößen geeignet sind und umfassende Support-Funktionen bieten. Durch die Integration dieser Suite mit Automapper können C#-Projekte erheblich verbessert werden, da zusätzliche Funktionen für die Datenverarbeitung und Dokumentenmanipulation zur Verfügung stehen.