C# 替换嵌套的foreach语句

我目前正在处理这样一种情况：我需要从数据库获取对象，将其映射到另一个对象，将其发送到视图模型，然后将其映射回数据库并保存到数据库

下面是我的示例程序。它很管用，但我对它的写作方式不满意。我觉得包装多个foreach语句对于其他程序员来说不是很可读

有谁能帮助我以更具可读性、也许更具性能的方式构造代码？例如，使用linq

语句。Select（）

或

。SelectMany（）

示例程序：

class Program
{
    static void Main(string[] args)
    {
        List<OldIncomeStructure> listOldPersonIncome = new List<OldIncomeStructure>();
        Balance balance = new Balance();
        PopulateBalance(ref balance);
        foreach(var personIncome in balance.IncomeOverview.PersonIncome)
        {
            OldIncomeStructure structure = new OldIncomeStructure();
            structure.PersonId = personIncome.PersonId;
            foreach(var prijem in personIncome.Incomes)
            {
                switch (prijem.IncomeTemplateId)
                {
                    case 1:
                        structure.MainJob = prijem.Amount;
                        break;
                    case 2:
                        structure.SideJob = prijem.Amount;
                        break;
                    case 3:
                        structure.Maternity = prijem.Amount;
                        break;
                    case 4:
                        structure.Retirement = prijem.Amount;
                        break;
                    case 5:
                        structure.Other = prijem.Amount;
                        break;    
                }
            }
            listOldPersonIncome.Add(structure);
        }   
        Console.ReadKey();
    }

    private static void PopulateBalance(ref Balance balance)
    {
        balance.PortfolioId = 1;
        balance.IncomeOverview = new IncomeOverview()
        {
            PersonIncome = new List<PersonalIncome>()
        };
        List<PersonalIncome> personalIncomes = new List<PersonalIncome>();
        personalIncomes.Add(new PersonalIncome
        {
            PersonId = 1,
            Incomes = new List<Income>()
            {
                new Income
                {IncomeTemplateId = 1,Amount = 110},
                new Income
                {IncomeTemplateId = 2, Amount = 120},
                new Income
                {IncomeTemplateId = 3, Amount = 130},
                new Income
                {IncomeTemplateId = 4, Amount = 140},
                new Income
                {IncomeTemplateId = 5, Amount = 150}
            }
        });
        personalIncomes.Add(new PersonalIncome
        {
            PersonId = 2,
            Incomes = new List<Income>()
            {
                new Income
                {IncomeTemplateId = 1,Amount = 210},
                new Income
                {IncomeTemplateId = 2, Amount = 220},
                new Income
                {IncomeTemplateId = 3, Amount = 230},
                new Income
                {IncomeTemplateId = 4, Amount = 240},
                new Income
                {IncomeTemplateId = 5, Amount = 250}
            }
        });
        balance.IncomeOverview.PersonIncome = personalIncomes;
        //naplnit pres linq
        var sum = 0;
        foreach(var person in balance.IncomeOverview.PersonIncome)
        {
            foreach(var income in person.Incomes)
            {
                sum += income.Amount;
            }
        }
        balance.IncomeOverview.Sum = sum;
    }
}

类程序
{
静态void Main（字符串[]参数）
{
List listOldPersonIncome=新列表（）；
余额=新余额（）；
人口平衡（参考平衡）；
foreach（变量personIncome in balance.IncomeOverview.personIncome）
{
OldIncomeStructure结构=新的OldIncomeStructure（）；
structure.PersonId=personIncome.PersonId；
foreach（个人收入中的var prijem）
{
开关（prijem.IncomeTemplateId）
{
案例1：
structure.MainJob=prijem.Amount；
打破
案例2：
structure.SideJob=prijem.Amount；
打破
案例3：
结构.生育=基本金额；
打破
案例4：
结构.退休=原金额；
打破
案例5：
结构.其他=原价金额；
打破
}
}
listOldPersonIncome.Add（结构）；
}   
Console.ReadKey（）；
}
专用静态空白填充平衡（参考平衡）
{
balance.PortfolioId=1；
balance.IncomeOverview=新的IncomeOverview（）
{
PersonIncome=新列表（）
};
List PersonalIncoments=新列表（）；
个人收入。添加（新的个人收入）
{
PersonId=1，
收入=新名单（）
{
新收入
{IncomeTemplateId=1，Amount=110}，
新收入
{IncomeTemplateId=2，Amount=120}，
新收入
{IncomeTemplateId=3，Amount=130}，
新收入
{IncomeTemplateId=4，Amount=140}，
新收入
{IncomeTemplateId=5，Amount=150}
}
});
个人收入。添加（新的个人收入）
{
PersonId=2，
收入=新名单（）
{
新收入
{IncomeTemplateId=1，Amount=210}，
新收入
{IncomeTemplateId=2，Amount=220}，
新收入
{IncomeTemplateId=3，Amount=230}，
新收入
{IncomeTemplateId=4，Amount=240}，
新收入
{IncomeTemplateId=5，Amount=250}
}
});
balance.IncomeOverview.PersonIncome=个人收入；
//naplnit pres linq
var总和=0；
foreach（var余额中的人员。收入概述。人员收入）
{
foreach（个人var收入。收入）
{
总和+=收入。金额；
}
}
balance.IncomeOverview.Sum=总和；
}
}

模型类：

public class OldIncomeStructure
{
    public int PersonId { get; set; }
    public int MainJob { get; set; }
    public int SideJob { get; set; }
    public int Maternity { get; set; }
    public int Retirement { get; set; }
    public int Other { get; set; }
}

public class Balance
{
    public int PortfolioId { get; set; }
    public IncomeOverview IncomeOverview { get; set; }
}

public class IncomeOverview
{
    public int Sum { get; set; }
    public List<PersonalIncome> PersonIncome { get; set;}
}

public class PersonalIncome
{
    public int PersonId { get; set; }
    public List<Income> Incomes { get; set; }
}

public class Income
{
    public int IncomeTemplateId { get; set; }
    public int Amount { get; set; }
}

公共类OldIncomeStructure
{
公共int PersonId{get；set；}
public int MainJob{get；set；}
public int SideJob{get；set；}
公共属性{get；set；}
公共整数{get；set；}
公共int-Other{get；set；}
}
公共阶级平衡
{
public int PortfolioId{get；set；}
公共收入概览收入概览{get；set；}
}
公共类收入概述
{
公共整数和{get；set；}
公共列表人名{get；set；}
}
公共阶层个人收入
{
公共int PersonId{get；set；}
公共列表{get；set；}
}
公共阶层收入
{
public int IncomeTemplateId{get；set；}
公共整数金额{get；set；}
}

我建议在性能成为问题之前不要担心性能，除非特别要求高性能。特别是，Linq可以有一些，但是对于可读性非常好，应该使用它

但是你对可读性的关注是很好的。以下是一些提示：

尝试确定具体的职责，并根据需要将其封装到函数/类中。特别是该区块的责任：

OldIncomeStructure结构=新的OldIncomeStructure（）；
structure.PersonId=personIncome.PersonId；
foreach（个人收入中的var prijem）
{
开关（prijem.IncomeTemplateId）
{
案例1：
structure.MainJob=prijem.Amount；
打破
案例2：
structure.SideJob=prijem.Amount；
打破
案例3：
结构.生育=基本金额；
打破
案例4：
结构.退休=原金额；
打破
案例5：
结构.其他=原价金额；
打破
}
}

可以总结为“从

PersonalIncome

实例创建一个新的

OldIncomeStructure

实例”。您可以将其封装到函数中，如下所示：

公共静态OldIncomeStructure CreateOldIncomeStructure（个人收入PersonalIncome）
{