フラット化マッピング（Flattening）

Jack Chan
100

出力結果

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を設定する