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

Hauptmerkmale von Automapper

• Vereinfachung des Codes: Automapper reduziert drastisch den Bedarf an manuellem Code, indem es die Zuordnung von Eigenschaften automatisiert, Fehler verhindert und Zeit spart.
• Flexibilität in Mapping-Konfigurationen: Automapper erlaubt eine detaillierte Anpassung der Mapping-Konfigurationen und deckt ein breites Spektrum an Mapping-Szenarien ab.
• Leistungsfähigkeit: Die Bibliothek ist darauf ausgelegt, große und komplexe Objektmodelle ohne signifikante Leistungseinbußen zu handhaben.

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 eine Instanz von IMapper unter Verwendung dieser Konfiguration 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 zeigt das Mapping zwischen User und UserDTO, wobei der FullName in UserDTO eine Verkettung von FirstName und LastName von 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 demonstriert das Mapping von einem Order-Objekt, das verschachtelte OrderedBy-Details enthält, zu einem flachen OrderDTO, wodurch Benutzernamen in eine einzelne FullName-Eigenschaft extrahiert und kombiniert werden.

Mit Version 9.0 ist AutoMapper von einer statischen API (Mapper.Initialize) zu einer instanzbasierten API übergegangen. 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 die Zuordnung von Eigenschaften zwischen verschiedenen Objektmodellen in C# vereinfacht, erweitern Iron Software's Bibliotheken die Funktionalität, indem sie Tools für den Umgang mit verschiedenen Datenformaten und -typen bieten. Zum Beispiel, nachdem Automapper verwendet wurde, um ein Benutzerdomänenobjekt in ein DTO zu transformieren, könnte IronPDF verwendet werden, um einen umfassenden Bericht im PDF-Format zu erstellen. Ähnlich könnte Daten, die mit Automapper extrahiert oder transformiert wurden, weiter manipuliert oder mit IronXL für Excel-Dateioperationen analysiert werden.