Ignoring properties that are nullable in the source but not nullable in the target

[sinanakyazici]

Hello guys,

AutoMapper Version : 10.1.1
AutoMapper.Collection Version : 7.0.1
.net core 3.1

I try to ignore null properties on source, I read a lot of things but I stuck in a point.

I want to do this for all props. I use ForAllMembers and Condition.

My Code:

    public class FoInvoiceIssueMappers : Profile
    {
        public FoInvoiceIssueMappers()
        {
            this.CreateMap<UpdateFoInvoiceIssueCommand, FoInvoiceIssue>().ForAllMembers(opts => opts.Condition((src, dest, srcMember) => srcMember != null));
        }
    }

This doesn't work when target is not nullable, srcMember gets default value of target type, For Example,

source prop type int? , target prop type int, srcMember is not null, is 0.
source prop type DateTime?, target prop type DateTime. srcMember is not null, is 1/1/0001 12:00:00 AM
source prop type bool?, target prop type bool, srcMember is not null, is false.

How I can fix this problem ?

I'm not sure if this is a bug.

[sinanakyazici]

Hello guys, I think authors won't help me. I solved my problem like this way, I hope this can help you.

    public class Tests
    {
        MapperConfiguration CreateConfiguration() => new(cfg =>
        {
            cfg.CreateMap<Source, Destination>()
                .ForMember(x => x.Age2, y => y.MapFrom(new IgnoreNullValueResolver<int?, int>(), x => x.Age))
                .IgnoreAllNull();
        });
        [SetUp]
        public void Setup()
        {
        }

        [Test]
        public void Test1()
        {
            var config = CreateConfiguration();
            var mapper = config.CreateMapper();
            var s1 = new Source {Age = 5, Time = DateTime.Now.AddDays(1)};
            var d1 = new Destination { Age = 1, Age2 = 3, Time = DateTime.Now };
            mapper.Map(s1, d1);

            var s2 = new Source {  };
            var d2 = new Destination { Age = 1, Age2 = 3, Time = DateTime.Now };
            mapper.Map(s2, d2);
        }
    }

    public class Source
    {
        public int? Age { get; set; }
        public DateTime? Time { get; set; }
    }

    public class Destination
    {
        public int Age { get; set; }
        public int Age2 { get; set; }
        public DateTime Time { get; set; }
    }

    public static class Helper
    {
        public static IMappingExpression<TSource, TDestination> IgnoreAllNull<TSource, TDestination>(this IMappingExpression<TSource, TDestination> m)
        {
            var sourceProps = typeof(TSource).GetProperties();
            var destinationProps = typeof(TDestination).GetProperties();
            var commonProps = destinationProps.Join(sourceProps, x => x.Name, y => y.Name, (x,y)=> x).OrderBy(x => x.Name).ToList();
            foreach (var prop in commonProps)
            {
                m.ForMember(prop.Name, x => x.MapFrom<IgnoreNullResolver<TSource, TDestination>, object>(prop.Name));
            }

            return m;
        }
    }

    public class IgnoreNullResolver<TSource, TDestination> : IMemberValueResolver<TSource, TDestination, object, object>
    {
        public object Resolve(TSource source, TDestination dest, object sourceMember, object destMember, ResolutionContext context)
        {
            return sourceMember ?? destMember;
        }
    }

    public class IgnoreNullValueResolver<TSourceMember, TDestinationMember> : IMemberValueResolver<object, object, TSourceMember, TDestinationMember>
    {
        public TDestinationMember Resolve(object source, object dest, TSourceMember sourceMember, TDestinationMember destMember, ResolutionContext context)
        {

            if (sourceMember == null)
            {
                return destMember;
            }

            var value = (TDestinationMember)Convert.ChangeType(sourceMember, typeof(TDestinationMember))!;
            return value;
        }
    }