Automapper to wszechstronna i potężna biblioteka w języku C#, zaprojektowana w celu ułatwienia mapowania obiektów, dzięki czemu transfer danych między złożonymi modelami obiektowymi staje się łatwiejszy i bardziej przystępny do utrzymania. W tym artykułe omówimy, w jaki sposób Automapper może efektywnie mapować właściwości, spłaszczać złożone modele obiektowe oraz pracować z różnymi typami obiektów, takimi jak obiekty domeny użytkownika i obiekty transferu danych.

Wprowadzenie do Automapper

Automapper w języku C# to mapper obiekt-obiekt, czyli narzędzie upraszczające konwersję i przesyłanie danych między różnymi typami obiektów. Jest to szczególnie przydatne w scenariuszach związanych z encjami danych i ich przekształcaniem w obiekty transferu danych (DTO).

Kluczowe funkcje Automapper

• Uproszczenie kodu: Automapper znacznie ogranicza konieczność ręcznego pisania kodu poprzez automatyzację mapowania właściwości, co zapobiega błędom i pozwala zaoszczędzić czas.
• Elastyczność konfiguracji mapowania: Automapper umożliwia szczegółowe dostosowywanie konfiguracji mapowania, obsługując szeroki zakres scenariuszy mapowania.
• Wydajność: Biblioteka została zaprojektowana do obsługi dużych i złożonych modeli obiektowych bez znaczącego obciążenia wydajnościowego.

Pierwsze kroki z Automapperem

Aby korzystać z Automappera, należy go najpierw zainstalować za pomocą konsoli menedżera pakietów, która jest częścią środowiska programistycznego ułatwiającą zarządzanie pakietami oprogramowania.

Instalacja za pomocą konsoli menedżera pakietów

Możesz łatwo zainstalować Automapper w swoim projekcie, wykonując proste polecenie w konsoli menedżera pakietów:

Install-Package AutoMapper

Konfiguracja podstawowych ustawień mapowania

Podstawowym krokiem w korzystaniu z Automappera jest zdefiniowanie konfiguracji mapowania. Wymaga to określenia, w jaki sposób właściwości obiektu wejściowego (źródła) powinny zostać przeniesione do obiektu wyjściowego (miejsca docelowego).

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

• W powyższym przykładzie utworzono konfigurację mapowania do mapowania właściwości z SourceClass do DestinationClass.
• Następnie tworzona jest instancja IMapper przy użyciu tej konfiguracji.

Zaawansowane techniki mapowania z Automapperem

Możliwości Automappera wykraczają daleko poza proste mapowanie właściwości do właściwości. Potrafi sprawnie radzić sobie z bardziej skomplikowanymi scenariuszami.

Spłaszczanie złożonych modeli obiektowych

Jedną z mocnych stron Automappera jest jego zdolność do spłaszczania złożonych modeli obiektowych. Ta funkcja jest szczególnie przydatna w przypadku obiektów zagnieżdżonych, umożliwiając mapowanie tych zagnieżdżonych właściwości na płaską strukturę klasy docelowej.

Wszechstronna obsługa typów obiektów

Automapper potrafi sprawnie mapować różne typy obiektów, w tym obiekty domeny użytkownika, DTO, a nawet modele widoku, zapewniając wszechstronne rozwiązanie dla różnych potrzeb związanych z transferem danych.

Praktyczne przykłady zastosowania

Aby lepiej zrozumieć użyteczność Automappera, przyjrzyjmy się kilku praktycznym przykładom.

Przykład 1: Proste mapowanie

Rozważmy scenariusz, w którym musimy zmapować właściwości z encji użytkownika do obiektu DTO użytkownika:

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)

• Ten przykład pokazuje mapowanie między User a UserDTO, gdzie FullName w UserDTO jest konkatenacją FirstName i LastName z User.

Przykład 2: Zaawansowane mapowanie złożonych obiektów

W bardziej złożonym scenariuszu spróbujmy zmapować obiekt zamówienia z zagnieżdżonymi danymi użytkownika na uproszczony obiekt DTO zamówienia:

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)

• Ten przykład demonstruje mapowanie z obiektu Order, zawierającego zagnieżdżone szczegóły OrderedBy, na płaski OrderDTO, wyodrębniając i łącząc imiona użytkowników w pojedynczą właściwość FullName.

Od wersji 9.0 AutoMapper przeszedł z API statycznego (Mapper.Initialize) na API oparte na instancjach. Ta zmiana zwiększa elastyczność i jest bardziej odpowiednia dla nowoczesnych aplikacji, zwłaszcza tych wykorzystujących wstrzykiwanie zależności. Jeśli pracujesz z wersjami starszymi niż 9.0, zastosowanie ma podejście oparte na statycznym API. Jednak w przypadku nowszych wersji zaleca się stosowanie interfejsu API opartego na instancjach, zgodnie z przykładami przedstawionymi powyżej.

Przegląd pakietu Iron Software Suite

Pakiet Iron Suite for .NET to solidny zestaw zawierający szereg bibliotek, z których każda służy konkretnemu celowi. Obejmuje on takie funkcje, jak tworzenie, odczytywanie i edycja plików PDF, konwersja HTML do PDF oraz przetwarzanie obrazów na tekst w wielu językach. Suite zaspokaja różne potrzeby programistów, co czyni ją wszechstronnym dodatkiem do każdego projektu w języku C#.

Kluczowe komponenty pakietu Iron Software Suite

1. IronPDF do zarządzania plikami PDF: Ten komponent pozwala programistom tworzyć, odczytywać, edytować i podpisywać pliki PDF. Oferuje również możliwość konwersji HTML do formatu PDF, co może być szczególnie przydatne przy generowaniu raportów lub dokumentacji na podstawie danych internetowych.

   

2. Obsługa plików Excel w IronXL: IronXL ułatwia pracę z plikami Excel bez konieczności korzystania z Office Interop, usprawniając zadania związane z przetwarzaniem i analizą danych.

   

3. IronOCR do wyodrębniania tekstu: Umożliwia wyodrębnianie tekstu z obrazów, obsługując szeroki wachlarz 125 języków, co czyni go niezwykle wszechstronnym narzędziem do projektów międzynarodowych.

   

4. Biblioteka IronBarcode do obsługi kodów QR i BarCode: biblioteka umożliwiająca odczyt i zapis kodów QR oraz BarCode, zwiększająca możliwości w zakresie zarządzania zapasami, śledzenia i innych powiązanych zadań.

Komplementarność z Automapperem

Chociaż Automapper exceluje w mapowaniu właściwości między różnymi modelami obiektów w C#, Biblioteki Iron Software rozszerzają funkcjonalność, oferując narzędzia do obsługi różnych formatów danych i typów. Na przykład, po użyciu Automappera do przekształcenia obiektu domenowego użytkownika w DTO, IronPDF można użyć do wygenerowania szczegółowego raportu w formacie PDF. Podobnie dane wyodrębnione lub przekształcone za pomocą Automappera mogą być dalej przetwarzane lub analizowane przy użyciu IronXL do operacji na plikach Excel.

Wnioski

Automapper to nieocenione narzędzie dla programistów C#, usprawniające mapowanie między obiektami. Jego rozbudowane możliwości w zakresie mapowania właściwości, obsługi złożonych modeli obiektowych oraz oferowania konfigurowalnych ustawień mapowania sprawiają, że jest to niezbędne narzędzie do wydajnego tworzenia oprogramowania. Zrozumienie zawiłości modeli obiektowych oraz sposobu konfiguracji Automappera pod kątem konkretnych potrzeb ma kluczowe znaczenie dla maksymalnego wykorzystania jego potencjału w każdym projekcie.

Pakiet Iron Suite firmy Iron Software oferuje różne opcje licencyjne, w tym bezpłatną wersję próbną oprogramowania Iron Software, dostosowaną do różnych potrzeb projektowych. Licencje są podzielone na poziomy Lite, Plus i Professional, dostosowane do różnych wielkości zespołów i zapewniające kompleksowe funkcje wsparcia. Zintegrowanie tej Suite z Automapperem może znacznie usprawnić projekty w języku C#, dodając możliwości przetwarzania danych i manipulacji dokumentami.