평탄화 매핑 (Flattening)

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

소스 객체(Person)에 대상 객체(People)와 일치하는 속성이 없을 경우, AutoMapper는 자동으로 다음 작업을 수행합니다:

소스 내부의 중첩 객체 속성을 분리: Cn.Name → 대상 CnName
Get으로 시작하는 매개변수 없는 메서드 매칭: GetTotal() → 대상 속성 Total

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

개념

AutoMapper는 기본적으로 동일한 이름의 속성을 매핑하는 것 외에도 평탄화(Flattening) 규칙을 따릅니다:

전체 코드

using AutoMapper;
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // AutoMapper 설정 초기화
            Mapper.Initialize(x =>
            {
                x.CreateMap();
            });

            // 소스 객체 Person
            Person p = new Person()
            {
                Age = 12,
                Cn = new Chinese() { Name = "Jack Chan" },
                Birthday = DateTime.Now,
                Sex = true,
                Salary = 5000
            };

            People peo = new People();

            // 매핑 실행
            Mapper.Map(p, peo);

            Console.WriteLine(peo.CnName);  // 출력: Jack Chan  [평탄화: Cn.Name → CnName]
            Console.WriteLine(peo.Total);   // 출력: 100        [평탄화: GetTotal() → Total]

            Console.ReadKey();
        }
    }

    // 소스 클래스
    class Person
    {
        public int Age { get; set; }
        // 중첩 객체
        public Chinese Cn { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }

        // Get으로 시작하는 매개변수 없는 메서드, Total 속성에 자동 매핑
        public decimal GetTotal()
        {
            return 100M;
        }
    }

    public class Chinese
    {
        public string Name { get; set; }
    }

    // 대상 클래스
    class People
    {
        public int Age { get; set; }
        // 평탄화 결과: 중첩 객체 Cn의 Name 속성을 CnName으로 연결
        public string CnName { get; set; }
        public decimal Salary { get; set; }
        public bool Sex { get; set; }
        public DateTime Birthday { get; set; }
        // 평탄화 결과: 소스의 GetTotal() 메서드와 매칭
        public decimal Total { get; set; }
    }
}

요약

중첩 객체 속성 자동 연결
소스: Person.Cn.Name
대상 속성명: CnName
AutoMapper가 중첩 객체 Cn과 Name을 자동으로 연결하여 CnName에 할당합니다. ForMember를 수동으로 설정할 필요가 없습니다.
Get으로 시작하는 매개변수 없는 메서드 매칭
소스 메서드: public decimal GetTotal()
대상 속성: public decimal Total
Get 접두사를 제거하고 메서드의 반환 값이 자동으로 Total에 할당됩니다.

출력 결과

Jack Chan
100

평탄화 매핑 (Flattening)

Previous: Profile 구성