DestinationTransform.EmptyCollectionIfNull overrides explicit null mapping

[moikot]

When DestinationTransform.EmptyCollectionIfNull is configured globally via config.Default, it still overrides explicitly defined mappings that return null.
This behavior is unexpected because explicit mappings (via .Map(...)) should take precedence over global/default transforms.

• Mapster version: 10.0.8-pre06
• .NET version: net10.0

class FooDto
{
 public string[]? Strings { get; set; }
}

record Foo(string?[] Strings);

public class DestinationTransformTests
{
 [Fact]
 public void ExplicitNullMapping_ShouldNotBeOverridden_ByDefaultEmptyCollectionTransform()
 {
 // Configure
 var config = new TypeAdapterConfig();

 config.Default
 .AddDestinationTransform(DestinationTransform.EmptyCollectionIfNull);

 config.NewConfig<Foo, FooDto>()
 .Map(d => d.Strings, _ => (string[]?)null);

 // Arrange
 var fooDto = new Foo([]);

 // Act
 var foo = fooDto.Adapt<FooDto>(config);

 // Assert
 foo.Strings.ShouldBeNull();
 }
}

Expected behavior

The explicit mapping:

.Map(d => d.Strings, _ => (string[]?)null)

should be respected, resulting in foo.Strings == null.

Actual behavior

foo.Strings is transformed into an empty array, meaning that EmptyCollectionIfNull is applied after the explicit mapping and overrides it.

Notes

The transform is registered on config.Default, not per-type.
This suggests that global destination transforms are applied at a stage where they override even explicit mapping results.
This makes it impossible to explicitly map a collection property to null when EmptyCollectionIfNull is enabled globally.

[DocSvartz]

Hi @moikot
DestinationTransform.EmptyCollectionIfNull is means, convert the destination to an empty collection if null is received from the source.

.Map(d => d.Strings, _ => (string[]?)null)
This is a setting to provide an alternative source.

[moikot]

@DocSvartz , I understand that, but semantically it feels strange to have a global setting (e.g., EmptyCollectionIfNull) without any way to override it.
Users are left with two equally cumbersome options:

1. Avoid using EmptyCollectionIfNull as a default and remember to apply it manually everywhere it’s needed. Which, in my case, is effectively 100% of DTO → domain mappings.
2. Use EmptyCollectionIfNull globally and rely on MapWith(...) to override the entire mapping for a type, which kind of defeats the purpose of using a mapper in the first place.

From my perspective, there should be a clear hierarchy:

• global settings,
• then the ability to override them at the type level,
• and finally at the property level.

[DocSvartz]

From my perspective, there should be a clear hierarchy:

global settings,
then the ability to override them at the type level,
and finally at the property level.

Currently the settings system is based on merging.
equal Unoin (globalDefault, ForDestiantonType, New<Source,Destination>)