UseValue ResolveUsing y sustitución nula en AutoMapper

Uso de resolución de valor y sustitución nula en AutoMapper

En este artículo, voy a hablar sobre UseValue ResolveUsing y Null Substitution en AutoMapper con ejemplos Lea nuestro artículo anterior donde discutimos la propiedad de ignorar de AutoMapper en C# con algunos ejemplos.

Comprender el AutoMapeador Métodos UseValue() y ResolveUsing()

El método AutoMapper UseValue() se usa para recuperar un valor en la primera ejecución y lo almacena en la asignación, mientras que el método ResolveUsing() se resuelve en tiempo de ejecución.

Entendamos el AutoMapper anterior  UseValue() y ResolveUsing()  métodos con un ejemplo

using AutoMapper;
namespace AutoMapperDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            InitializeAutomapper();

            A aObj = new A()
            {
                Name = "Pranaya",
                AAddress = "Mumbai"
            };

            var bObj = Mapper.Map<A, B>(aObj);
            Console.WriteLine("After Mapping : ");

            //Here FixedValue and DOJ will be empty for aObj
            Console.WriteLine("aObj.Member : " + aObj.Name + ", aObj.FixedValue : " + aObj.FixedValue + ", aObj.DOJ : " + aObj.DOJ + ", aObj.AAddress : " + aObj.AAddress);
            Console.WriteLine("bObj.Member : " + bObj.Name + ", bObj.FixedValue : " + bObj.FixedValue + ", bObj.DOJ : " + bObj.DOJ + ", bObj.BAddress : " + bObj.BAddress);
            
            bObj.Name = "Rout";
            bObj.BAddress = "Delhi";
            Mapper.Map(bObj, aObj);

            Console.WriteLine("After ReverseMap : ");
            Console.WriteLine("aObj.Member : " + aObj.Name + ", aObj.FixedValue : " + aObj.FixedValue + ", aObj.DOJ : " + aObj.DOJ + ", aObj.AAddress : " + aObj.AAddress);
            Console.WriteLine("bObj.Member : " + bObj.Name + ", bObj.FixedValue : " + bObj.FixedValue + ", bObj.DOJ : " + bObj.DOJ + ", bObj.BAddress : " + bObj.BAddress);

            Console.ReadLine();
        }

        static void InitializeAutomapper()
        {
            Mapper.Initialize(config =>
            {
                config.CreateMap<A, B>()
                    .ForMember(dest => dest.BAddress, act => act.MapFrom(src => src.AAddress))

                    //To Store Static Value use the UseValue() method
                    .ForMember(dest => dest.FixedValue, act => act.UseValue("Hello"))

                    //To Store DateTime value use ResolveUsing() method
                    .ForMember(dest => dest.DOJ, act => act.ResolveUsing(src =>
                    {
                        return DateTime.Now;
                    }))

                    .ReverseMap();
            });
        }
    }

    public class A
    {
        public string Name { get; set; }
        public string AAddress { get; set; }
        public string FixedValue { get; set; }
        public DateTime DOJ { get; set; }
    }

    public class B
    {
        public string Name { get; set; }
        public string BAddress { get; set; }
        public string FixedValue { get; set; }
        public DateTime DOJ { get; set; }
    }
}

Cuando ejecuta la aplicación, obtiene el siguiente resultado.

Nota: Utilice MapFrom(s => s.MemberName) cuando devuelve el miembro del objeto de origen real, mientras que necesita usar UseValue() si desea asignar un valor estático en la asignación y sabe que el valor en sí no cambiará.

Usar ResolveUsing(s => {}) cuando desee resolver un campo de destino a partir de un valor derivado. Esto debe usarse para cualquier asignación de fecha y hora y cualquier función de asignación más complicada.

Sustitución nula en Automapper:

La sustitución nula nos permite proporcionar un valor alternativo para un miembro de destino si el valor de origen es nulo. Eso significa que en lugar de asignar el valor nulo del objeto de origen, se asignará a partir del valor que proporcionamos. Necesitamos usar NullSubstitute() método para sustituir el valor nulo usando AutoMapper.

Veamos cómo usar la sustitución nula usando AutoMapper con un ejemplo

using AutoMapper;
namespace AutoMapperDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            InitializeAutomapper();

            A aObj = new A()
            {
                Name = "Pranaya",
                AAddress = null
            };

            var bObj = Mapper.Map<A, B>(aObj);
            Console.WriteLine("After Mapping : ");

            //Here FixedValue and DOJ will be empty for aObj
            Console.WriteLine("aObj.Member : " + aObj.Name + ", aObj.FixedValue : " + aObj.FixedValue + ", aObj.AAddress : " + aObj.AAddress);
            Console.WriteLine("bObj.Member : " + bObj.Name + ", bObj.FixedValue : " + bObj.FixedValue + ", bObj.BAddress : " + bObj.BAddress);

            Console.ReadLine();
        }

        static void InitializeAutomapper()
        {
            Mapper.Initialize(config =>
            {
                config.CreateMap<A, B>()
                    .ForMember(dest => dest.BAddress, act => act.MapFrom(src => src.AAddress))
                    //You need to use NullSubstitute method to substitute null value
                    .ForMember(dest => dest.FixedValue, act => act.NullSubstitute("Hello"))
                    .ForMember(dest => dest.BAddress, act => act.NullSubstitute("N/A"));
            });
        }
    }

    public class A
    {
        public string Name { get; set; }
        public string AAddress { get; set; }
        public string FixedValue { get; set; }
    }

    public class B
    {
        public string Name { get; set; }
        public string BAddress { get; set; }
        public string FixedValue { get; set; }
    }
}

Cuando ejecutamos la aplicación, nos dará el siguiente resultado.

En este artículo, trato de explicar UseValue ResolveUsing y Null Substitution usando AutoMapper en C# con algunos ejemplos. Espero que este artículo te ayude con tu necesidad. Me gustaría tener sus comentarios. Publique sus comentarios, preguntas o comentarios sobre este artículo.