Shulou(Shulou.com)06/01 Report--

Editor to share with you how to configure the ABP framework to use object mapping, I believe most people do not know much about it, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to know it!

DTO and entity

Entity is a concept in domain driven design (Domain Driven Design). Entities usually map the inherent attributes of some objects one by one, and tables in relational databases are most commonly used.

In ABP, the entity is located in the domain layer, and the entity class needs to implement the IEntity interface or inherit the Entity base class. The example is as follows:

Public class Book: Entity {public string Name {get; set;} public float Price {get; set;}} DTO

Data transfer object (Data Transfer Object), as a data model in the process of data transfer, is used to transfer data between the application layer and the presentation layer.

In ABP, DTO is located in the application services layer, the AbpBase.Application project in the sample source code for this series of articles.

Usually, when the presentation layer or other type of client invokes the application service, it passes DTO as a parameter, which uses the domain object (entity) to execute some specific business logic and returns the DTO (which is not the same as the incoming DTO) to the presentation layer, so the presentation layer is completely isolated from the domain layer.

The DTO class may be very similar to the fields / properties of the entity class, and creating a DTO class for each method of each service can be tedious and time-consuming.

An example of the DTO class for ABP is as follows:

Public class ProductDto: EntityDto {public string Name {get; set;} / /.} troublesome mapping

As mentioned earlier, the domain layer and the application services layer are isolated, such as the following pseudocode:

Class HomeController {AddService _ service; [HttpPost] public int AddEquip (EquipDto dto) {return _ service.Add (dto) .ID;}} class AddService {DataContext _ context; EquipDto Add (EquipDto dto) {Equip equip = new Equip () {Name = dto.Name;}; _ context.Equip.Add (equip); _ context.SaveChange () Dto.Id = equip.Id; return dto;}} class EquipDto {int Id; string Name;}-class Equip {int Id; string Name;}

This requires manual field mapping for DTO classes and entity classes each time. When an entity has dozens of fields, the code is lengthy, and some fields are easily ignored, resulting in Bug.

As we all know, AutoMapper can solve this problem.

AutoMapper integration

ABP's Volo.Abp.AutoMapper module encapsulates or integrates AutoMapper, so we happen to use the module to define object mappings for ABP applications.

About the use of AutoMapper, how to configure Profile, etc., the author has separately written to shallow AutoMapper, please click the link to learn the use of AutoMapper.

We can create a new AbpBaseApplicationAutoMapperProfile.cs file in the AbpBase.Application project that implements Profile and defines the mapping. Centralize the mapping of the service domain into this file, or create a new Profiles folder and store some Profile classes in it.

Its contents are as follows:

Public class AbpBaseApplicationAutoMapperProfile:Profile {public AbpBaseApplicationAutoMapperProfile () {/ / base.CreateMap ();}}

After the definition is completed, you need to configure AutoMapper dependency injection. Add the following code to the ConfigureServices method of AbpBaseApplicationModule:

Configure (options = > {/ / register mapping options.AddMaps () by module; / register mapping by single Profiel / / options.AddProfile ();})

In the Debug phase, we are worried that when the project changes the code, the new fields forget to be added to the mapping configuration, or otherwise, in AutoMapper, we can use configuration.AssertConfigurationIsValid (); to check the mapping; in ABP, we can use the validate: true parameter to turn on the check.

Configure (options = > {/ / register mapping options.AddMaps (validate: true) on a module basis; / register mapping / / options.AddProfile (validate: true) on a single Profiel basis; IObjectMapper/ObjectMapper

In the AbpBase.Application project, add the Nuget package, search for Volo.Abp.ObjectMapping, and download the corresponding stable version.

IObjectMapper has two, one is the interface of AutoMapper, the other is the generic interface of Volo.Abp.ObjectMapping.

AutoMapper's IObjectMapper doesn't work, so don't use it; use Volo.Abp.ObjectMapping 's IObjectMapper.

ObjectMapper is in AutoMapper, so we can use ObjectMapper injection directly in the controller and so on, and then map the object through the ObjectMapper instance.

Map () is the only method that works well for ObjectMapper.

Private readonly ObjectMapper _ mapper; public TestController (ObjectMapper mapper) {_ mapper = mapper; / /. Use the example _ = mapper.Map ();}

You can also use the IObjectMapper interface through dependency injection.

But because ObjectMapper is a generic class, it would be troublesome to inject each type of DTO once, so this solution can also be abandoned.

While generic IObjectMapper is an abstraction, if we use IObjectMapper for dependency injection, if we replace it with another object mapping framework, we don't need to modify the original code to complete the substitution. And IObjectMapper is more comfortable.

Examples of use:

Private readonly IObjectMapper _ mapper; public TestController (IObjectMapper mapper) {_ mapper = mapper; / /. Use the example _ = mapper.Map ();} object extension

The ABP framework provides an entity extension system that allows you to add additional attributes to existing objects without modifying related classes. This sentence is copied from the official document of ABP.

To support object extension mapping, you need to turn on the configuration:

Public class MyProfile: Profile {public MyProfile () {CreateMap () .MapExtraProperties ();}}

Time is limited, the author here only explain the content of the official document clearly, after reading, readers need to continue to consult the official document to fully understand the object expansion.

ObjectExtensionManager is an extended object mapping class that explicitly extends some additional attributes to the class, which is defined in Volo.Abp.ObjectMapping.

ObjectExtensionManager is a type, but we can't new it directly, or use dependency injection, we can only get new types through the ObjectExtensionManager.Instance attribute. We don't have to care about what design pattern it uses, or whether it is designed for reasons such as caching.

ObjectExtensionManager has two properties, which are described as follows:

AddOrUpdate: is the main way to define or update extra properties of an object

AddOrUpdateProperty: a quick way to define a single extended attribute

AddOrUpdateProperty is used to define a single attribute, and AddOrUpdate is a container that can contain multiple AddOrUpdateProperty.

The sample code for AddOrUpdateProperty is as follows:

ObjectExtensionManager.Instance .AddOrUpdateProperty ("Name"); / / added a G property for the TestA class

The sample code for AddOrUpdate is as follows:

ObjectExtensionManager.Instance .AddOrUpdate (options = > {options.AddOrUpdateProperty ("Name"); options.AddOrUpdateProperty ("Nice");})

Of course, we can also define an additional property for multiple types at the same time:

ObjectExtensionManager.Instance .AddOrUpdateProperty (new [] {typeof (TestA), typeof (TestB), typeof (TestC)}, "Name")

If you need to define multiple properties, you can use AddOrUpdate:

ObjectExtensionManager.Instance .AddOrUpdate (options = > {options.AddOrUpdateProperty ("Name");}, new [] {typeof (TestA), typeof (TestB)}) These are all the contents of the article "how to configure the ABP framework to use object mapping". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.