Unable to map struct from object in another object

[jankoci91]

Hi! Am I right that failing assert in this test means bug?

In version 6.5.1 it works fine.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Shouldly;

namespace Mapster.Tests
{
    [TestClass]
    public class WhenMappingStructInObject
    {
        class Destination
        {
            public TestStruct TestStruct { get; set; }
        }

        class SourceWithClass
        {
            public SourceWithStruct SourceWithStruct { get; set; }
        }

        class SourceWithStruct
        {
            public TestStruct TestStruct { get; set; }
        }

        struct TestStruct
        {
            public string Property { get; }

            public TestStruct(string property) : this()
            {
                Property = property;
            }
        }

        [TestMethod]
        public void TestMapping()
        {
            TypeAdapterConfig<SourceWithClass, Destination>
                .ForType()
                .Map(x => x.TestStruct, x => x.SourceWithStruct.TestStruct);

            var source = new SourceWithClass
            {
                SourceWithStruct = new SourceWithStruct
                {
                    TestStruct = new TestStruct("A")
                }
            };

            var destination = source.Adapt<Destination>();

            destination.TestStruct.Property.ShouldBe("A");
        }
    }
}

[codelovercc]

Any exception stack trace?

[jankoci91]

There is no exception I'm aware of. Just null instead of "A" as result.

[andrerav]

@jankoci91 Which NuGet package version are you using?

[jankoci91]

7.3.0 Sorry for missing info.

[andrerav]

@jankoci91 Can you try the latest prerelease package please?

[jankoci91]

Done. Same result. Null instead of "A".

[DocSvartz]

Hello, This is another type of bug #537 . Struct is detected as Record in

Mapster/src/Mapster/Utils/ReflectionUtils.cs

Line 161 in 04ac871

public static bool IsRecordType(this Type type)

[andrerav]

Thank you @jankoci91 and @DocSvartz. I ran a git bisect session using the test posted by @jankoci91 above, and ended up with 773f64a as the supposed culprit. Still trying to piece this together, but now we know which commit that introduced the problem that causes this test to fail.

[andrerav]

@DocSvartz I think you're spot on. IsRecordType() is detecting types as record when it should not.

[DocSvartz]

@andrerav I managed to make a partial fix.
It seems that problems with collections #430 and modification by an Object of type #524 have a different reason for bug.
This bug hit Fork and Clone config. There, too, instances are not created transparently. But based on tests, this behavior is legitimate.

[stagep]

In order to identify issues that are still active, we are closing issues that we believe are either resolved or are dormant. If your issue is still active then please reopen. Thanks.

[semi07]

I’ve encountered a similar issue.
Mapster correctly maps a direct property like: dest => dest.Amount, src => src.Amount.
However, it fails to map nested properties such as: dest => dest.InnerAmount, src => src.Inner.Amount

InnerAmount always ends up with the default value (NULL EUR).

Similar problem with PartnerCode.
bar.InnerPartnerCode.Value contains the type name instead of the expected value: "Tests.Tools.PartnerCode".

It works when I define mapping like this:

.Map(dest => dest.InnerPartnerCode, src => new PartnerCode(src.Inner.PartnerCode.Value, src.Inner.PartnerCode.IsForeigner))
.Map(dest => dest.InnerAmount, src => new Money(src.Inner.Amount.Amount, src.Inner.Amount.Currency))

I’m looking for a global solution, because I would prefer not to change all my individual mappings.
Has anyone experienced this or knows what might cause Mapster to behave differently for nested mappings?

[TestClass]
public class MapsterConverterTest
{
    [TestMethod]
    public async Task LoadTariffsTest()
    {
        // Arrange
        var config = TypeAdapterConfig.GlobalSettings;
        Register(config);
        config.Default.ShallowCopyForSameType(true);
        config.Default.MapToConstructor(true);
        config.Default.IgnoreNullValues(true);
        config.Default.MaxDepth(10);
        config.Default.NameMatchingStrategy(NameMatchingStrategy.Flexible);
        config.Default.AddDestinationTransform((string? s) => string.IsNullOrEmpty(s) ? null : s);
        config.RequireExplicitMapping = false;
        config.Compile();

        Foo foo = new()
        {
            Amount = new(1, Currency.Usd),
            PartnerCode = new("company", true),
            Inner = new()
            {
                Amount = new(10, Currency.Eur),
                Int = 100,
                PartnerCode = new("Inner company", true)
            }
        };

        // Act
        var bar = foo.Adapt<Bar>(config);

        // Assert
        Assert.AreEqual(10m, bar.InnerAmount.Amount);
    }

    private void Register(TypeAdapterConfig config)
    {
        config.ForType<Foo, Bar>()
            .Map(dest => dest.Amount, src => src.Amount)
            .Map(dest => dest.InnerAmount, src => src.Inner.Amount)
            .Map(dest => dest.PartnerCode, src => src.PartnerCode)
            .Map(dest => dest.InnerPartnerCode, src => src.Inner.PartnerCode)
            //.Map(dest => dest.InnerAmount, src => new Money(src.Inner.Amount, src.Inner.Amount.Currency))
            .Map(dest => dest.InnerInt, src => src.Inner.Int);

        config.NewConfig<PartnerCode, PartnerCode>()
            .MapWith(src => src);
    }
}

file class Foo
{
    public required Money Amount { get; set; }
    public PartnerCode PartnerCode { get; set; }
    public required FooInner Inner { get; set; }
}

file class FooInner
{
    public required Money Amount { get; set; }
    public PartnerCode PartnerCode { get; set; }
    public int Int { get; set; }
}

file class Bar
{
    public required Money Amount { get; set; }
    public required Money InnerAmount { get; set; }
    public int InnerInt { get; set; }
    public PartnerCode PartnerCode { get; set; }
    public PartnerCode InnerPartnerCode { get; set; }
}

public struct PartnerCode(string? value, bool isForeigner)
{
    public string? Value { get; set; } = value;
    public bool IsForeigner { get; set; } = isForeigner;
}

public struct Money
{
    public decimal? Amount { get; set; }

    public Currency Currency { get; set; } = Currency.Ron;

    public Money(decimal? amount, Currency currency = Currency.Eur)
    {
        Amount = amount;
        Currency = currency;
    }
}