var dtos = ObjectMapper.Map<List<User>, List<UserDto>>(users); // creates List<UserDto>
var dtos = ObjectMapper.Map<List<User>, List<UserDto>>(users); // creates List<UserDto>
````
````
### Nested Mapping
When working with nested object mapping, there's an important limitation to be aware of. If you have separate mappers for nested types like in the example below, the parent mapper (`SourceTypeToDestinationTypeMapper`) will not automatically use the nested mapper (`SourceNestedTypeToDestinationNestedTypeMapper`) to handle the mapping of nested properties. This means that configurations like the `MapperIgnoreTarget` attribute on the nested mapper will be ignored during the parent mapping operation.
````csharp
public class SourceNestedType
{
public string Name { get; set; }
public string Ignored { get; set; }
}
public class SourceType
{
public string Name { get; set; }
public SourceNestedType Nested { get; set; }
}
public class DestinationNestedType
{
public string Name { get; set; }
public string Ignored { get; set; }
}
public class DestinationType
{
public string Name { get; set; }
public DestinationNestedType Nested { get; set; }
}
[Mapper]
public partial class SourceTypeToDestinationTypeMapper : MapperBase<SourceType,DestinationType>
{
public override partial DestinationType Map(SourceType source);
public override partial void Map(SourceType source, DestinationType destination);
}
[Mapper]
public partial class SourceNestedTypeToDestinationNestedTypeMapper : MapperBase<SourceNestedType,DestinationNestedType>
public override partial void Map(SourceNestedType source, DestinationNestedType destination);
}
````
There are several ways to solve this nested mapping issue. Choose the approach that best fits your specific requirements:
#### Solution 1: Multi-Interface Implementation
Implement both mapping interfaces (`IAbpMapperlyMapper<SourceType,DestinationType>` and `IAbpMapperlyMapper<SourceNestedType, DestinationNestedType>`) in a single mapper class. This approach consolidates all related mapping logic into one class.
**Important:** Remember to implement `ITransientDependency` to register the mapper class with the dependency injection container.
````csharp
[Mapper]
public partial class SourceTypeToDestinationTypeMapper : IAbpMapperlyMapper<SourceType,DestinationType>, IAbpMapperlyMapper<SourceNestedType,DestinationNestedType>, ITransientDependency
{
public partial DestinationType Map(SourceType source);
public partial void Map(SourceType source, DestinationType destination);
public void BeforeMap(SourceType source)
{
}
public void AfterMap(SourceType source, DestinationType destination)
public partial void Map(SourceNestedType source, DestinationNestedType destination);
public void BeforeMap(SourceNestedType source)
{
}
public void AfterMap(SourceNestedType source, DestinationNestedType destination)
{
}
}
````
#### Solution 2: Consolidate Mapping Methods
Copy the nested mapping methods from `SourceNestedTypeToDestinationNestedTypeMapper` to the parent `SourceTypeToDestinationTypeMapper` class. This ensures all mapping logic is contained within a single mapper.
Example:
````csharp
[Mapper]
public partial class SourceTypeToDestinationTypeMapper : MapperBase<SourceType,DestinationType>
{
public override partial DestinationType Map(SourceType source);
public override partial void Map(SourceType source, DestinationType destination);
- **Solution 1** consolidates all mapping logic in one place and works well when mappings are tightly related.
- **Solution 2** is simple but can lead to code duplication if you need the nested mapper elsewhere.
- **Solution 3** maintains separation of concerns and reusability but requires manual mapping in the `AfterMap` method.
Choose the approach that best aligns with your application's architecture and maintainability requirements.
### More Mapperly Features
### More Mapperly Features
Most of Mapperly's features such as `Ignore` can be configured through its attributes. See the [Mapperly documentation](https://mapperly.riok.app/docs/intro/) for more details.
Most of Mapperly's features such as `Ignore` can be configured through its attributes. See the [Mapperly documentation](https://mapperly.riok.app/docs/intro/) for more details.
This document contains **brief release notes** for each ABP Studio release. Release notes only include **major features** and **visible enhancements**. Therefore, they don't include all the development done in the related version.
This document contains **brief release notes** for each ABP Studio release. Release notes only include **major features** and **visible enhancements**. Therefore, they don't include all the development done in the related version.
## 1.2.1 (2025-08-14)
* Upgraded template dependencies for ABP Framework and LeptonX. (targeting ABP `9.3.1`)
* Migrated templates to standalone structure for Angular UI.
* Allowed relating tools with Kubernetes Services (allows to browse tools dashboard those are running in k8s).
* Made several enhancements for Solution Runner.
* Added test projects to **Application (Single Layer)** template (optional).
## 1.1.2 (2025-07-31)
## 1.1.2 (2025-07-31)
* Upgraded template dependencies for ABP Framework and LeptonX. (targeting ABP `9.2.3`)
* Upgraded template dependencies for ABP Framework and LeptonX. (targeting ABP `9.2.3`)
enisn
1 year ago