Entity Framework：如何返回包含多实体的强类型对象？

嗨，我明白你现在的需求——把松散的dynamic列表换成强类型对象，既能整合三张表的数据，又能让前端GridView的排序功能稳稳运行。下面一步步来实现：

第一步：创建匹配需求的强类型DTO类 #

既然要整合Company所有列、Financial所有列，再加FinancialHistory部分列，而且Financial和FinancialHistory是一对多关系，我们可以设计一个主DTO，嵌套一个子DTO来存FinancialHistory的部分字段：

// 主DTO：整合Company + Financial + 关联的FinancialHistory列表
public class CompanyFinancialDto
{
    // Company表的所有列，示例字段：
    public int CompanyId { get; set; }
    public string CompanyName { get; set; }
    public string LegalAddress { get; set; }
    // ... 按你的实体模型补充其他Company字段

    // Financial表的所有列，示例字段：
    public int FinancialId { get; set; }
    public decimal AnnualRevenue { get; set; }
    public decimal NetProfit { get; set; }
    public DateTime ReportPeriodEnd { get; set; }
    // ... 按你的实体模型补充其他Financial字段

    // FinancialHistory的部分列，用子DTO列表存储（一对多关系）
    public List<FinancialHistorySummaryDto> FinancialHistories { get; set; } = new List<FinancialHistorySummaryDto>();
}

// 子DTO：只存FinancialHistory需要的部分列
public class FinancialHistorySummaryDto
{
    public int HistoryRecordId { get; set; }
    public decimal PreviousPeriodRevenue { get; set; }
    public DateTime HistoryCreatedDate { get; set; }
    // ... 只添加你实际需要的FinancialHistory字段
}

第二步：用EF查询填充强类型对象 #

你已经有实体模型，直接用EF的投影查询（Select）来构建DTO，既能精准获取需要的字段，又避免加载冗余数据：

public List<CompanyFinancialDto> GetCompanyFinancialData()
{
    using (var context = new YourDbContext())
    {
        var result = context.Companies
            .Include(c => c.Financial) // 关联一对一的Financial表
            .Include(c => c.Financial.FinancialHistories) // 关联一对多的FinancialHistory表
            .Select(c => new CompanyFinancialDto
            {
                // 映射Company的所有字段
                CompanyId = c.CompanyId,
                CompanyName = c.CompanyName,
                LegalAddress = c.LegalAddress,
                // ... 补充其他Company字段

                // 映射Financial的所有字段
                FinancialId = c.Financial.FinancialId,
                AnnualRevenue = c.Financial.AnnualRevenue,
                NetProfit = c.Financial.NetProfit,
                ReportPeriodEnd = c.Financial.ReportPeriodEnd,
                // ... 补充其他Financial字段

                // 映射FinancialHistory的部分字段到子DTO列表
                FinancialHistories = c.Financial.FinancialHistories
                    .Select(fh => new FinancialHistorySummaryDto
                    {
                        HistoryRecordId = fh.HistoryRecordId,
                        PreviousPeriodRevenue = fh.PreviousPeriodRevenue,
                        HistoryCreatedDate = fh.HistoryCreatedDate
                        // ... 补充其他需要的字段
                    })
                    .ToList()
            })
            .ToList();

        return result;
    }
}

只要你的实体模型中Company和Financial的导航属性配置正确（一对一关联），上面的查询就能完美关联三张表的数据。

第三步：支持前端GridView的排序功能 #

强类型的核心优势之一就是能轻松实现可靠的动态排序，这里推荐两种实用方式：

方式1：手动判断排序字段（适合字段较少的场景） #

直接根据前端传入的排序字段和方向构建LINQ查询，编译时就能保证类型安全：

public List<CompanyFinancialDto> GetSortedCompanyFinancialData(string sortField, bool isAscending)
{
    using (var context = new YourDbContext())
    {
        var query = context.Companies
            .Include(c => c.Financial)
            .Include(c => c.Financial.FinancialHistories)
            .Select(c => new CompanyFinancialDto
            {
                // 映射字段和上面一致，省略重复代码
            });

        // 根据前端传入的排序规则处理
        switch (sortField.ToLower())
        {
            case "companyname":
                query = isAscending ? query.OrderBy(dto => dto.CompanyName) : query.OrderByDescending(dto => dto.CompanyName);
                break;
            case "annualrevenue":
                query = isAscending ? query.OrderBy(dto => dto.AnnualRevenue) : query.OrderByDescending(dto => dto.AnnualRevenue);
                break;
            case "reportperiodend":
                query = isAscending ? query.OrderBy(dto => dto.ReportPeriodEnd) : query.OrderByDescending(dto => dto.ReportPeriodEnd);
                break;
            // 按需添加其他需要排序的字段
            default:
                query = query.OrderBy(dto => dto.CompanyId); // 设置默认排序规则
                break;
        }

        return query.ToList();
    }
}

方式2：使用动态LINQ库（适合字段较多的场景） #

如果需要排序的字段很多，手动写switch太繁琐，可以安装System.Linq.Dynamic.Core NuGet包，直接接收字符串形式的排序表达式：

// 先安装NuGet包：System.Linq.Dynamic.Core
public List<CompanyFinancialDto> GetSortedCompanyFinancialData(string sortExpression)
{
    using (var context = new YourDbContext())
    {
        var query = context.Companies
            .Include(c => c.Financial)
            .Include(c => c.Financial.FinancialHistories)
            .Select(c => new CompanyFinancialDto
            {
                // 映射字段和上面一致，省略重复代码
            })
            .OrderBy(sortExpression); // 直接传入类似"CompanyName asc"或"AnnualRevenue desc"的字符串

        return query.ToList();
    }
}

前端只需要把排序字段和方向拼成字符串传过来就行，非常灵活，而且强类型DTO能避免dynamic常见的运行时拼写错误。

为什么强类型更适合你的场景？ #

• 类型安全：编译时就能发现字段名拼写错误，不会出现dynamic的运行时异常
• 前端绑定友好：GridView可以直接绑定强类型对象的属性，排序字段名和DTO属性一一对应，不容易出错
• 可维护性：后续修改表结构或需求时，DTO的修改一目了然，团队协作更顺畅

内容的提问来源于stack exchange，提问作者bob56