. Net automapper use

When decomposing complex software systems , One of the technologies most used by software designers is layering . Layered right has many advantages ： Such as improving reusability 、 Low coupling , But it also has its shortcomings ： For example, too many levels will affect performance 、 Sometimes it brings us cascading modifications .

It will bring cascading modifications. How to understand ？ For example, when the demand changes, a data field displayed on the user interface should be added , You must add corresponding fields to the data , You must also make corresponding changes at each layer between the user interface and the database . There will be different data entity classes in different levels （ Some classes also include methods ）, In order to realize data transmission between these entity classes, the transformation before the class must be carried out , This kind of conversion can complete the task by handwritten code for one-to-one conversion , Just like the picture below , And you have to work for the corresponding List<T> Class to write the corresponding conversion method , There is a simpler and more convenient solution for you ？ That's what the title says AutoMapper, From the name, we can see that this is a tool for mapping .

Go straight to the code , First, define the entity class that needs to be converted , The second step is to inherit Profile Interface , To register .

using AutoMapper;

namespace WindowsFormsApp1
{
    /// <summary>
    ///  Imitate the data entity classes that need to be converted 
    /// </summary>
    public class Source
    {
        public int SomeValue { get; set; }
        public string AnotherValue { get; set; }
    }

    /// <summary>
    ///  Imitate the data entity classes that need to be converted 
    /// </summary>
    public class Destination
    {
        public int SomeValue { get; set; }
    }

    /// <summary>
    ///  adopt Profile register 
    ///  tell AutoMapper Which classes need to be converted , If A convert to B,B It should also be converted into A, Then you need to write two 
    /// </summary>
    public class SourceProfile : Profile
    {
        public SourceProfile()
        {
            CreateMap<Source, Destination>();
            CreateMap<Destination, Source>();
        }
    }
}

The third step is to Profile The mapping relationship written in the Chinese book is added to Mapper example , The routine needs to write a method to get the unique Mapper example （ The singleton pattern ）, The mapping relationship is configured in the instance .

using AutoMapper;

namespace WindowsFormsApp1
{
    public class AutoMapperConfigure
    {
        public static IMapper GetMapper()
        {
            var config = new MapperConfiguration(cfg =>
            {
                //  Scan the current assembly 
                cfg.AddMaps(System.AppDomain.CurrentDomain.GetAssemblies());
            });

            var mapper = config.CreateMapper();
            return mapper;
        }
    }
}

Step 4 call , By default ,AutoMapper Map based on the same field name , And is Case insensitive Of . You can also modify the configuration , Realization AutoMapper Provided naming rule mapping .LowerUnderscoreNamingConvention and PascalCaseNamingConvention yes AutoMapper Two naming rules provided . The former is named lowercase and contains underscores , The latter is Pascal's naming rule （ Capitalize each word ）.

        private void promptMessageButton_Click(object sender, EventArgs e)
        {
            Source source = new Source()
            {
                SomeValue = 1,
                AnotherValue = "Another"
            };

            var mapper = AutoMapperConfigure.GetMapper();
            Destination destination = mapper.Map<Destination>(source);
            MessageBox.Show(destination.SomeValue.ToString());
        }

Like the first screenshot, the more complex one involves the conversion between enumeration and enumeration description , even to the extent that List<string> convert to string, It can also be used. AutoMapper Realization . You can call the written static method on the converted member property , To realize the quasi exchange according to the rules , Here's the picture .

Reference material ：https://www.cnblogs.com/gl1573/p/13098031.html

Interested students can also see the official documents , There are also examples ：https://docs.automapper.org/en/latest/

The students who read the blog suggest writing it by themselves , To borrow a sentence from Xunzi ： No smell, no smell , You can't hear it, you can't see it , If you don't know what you see , What you know is not what you do . If you have any questions, please discuss with me .