如何将带语句体的Select表达式传入.Select()而非内联声明

背景与代码 #

我当前有一段可正常运行的代码，用于同步患者数据并序列化为指定格式的JSON：

// databaseHelper.GetPatientsForCompanyAsync uses Dapper to return a collection
// of Patient Objects.  The .Select is used to transform the collection
// into a set of anonymous types so that when they are serialized to
// to json, the property names will be what the receiving API wants
public async Task SyncPatientData(ProcessType processType)
{
    logger.LogInformation($"Started SyncPatientData");
    var companies = await GetCompanySettingsAsync(processType);
     
    foreach (var company in companies)
    {
        logger.LogInformation($"Processing company {company.ConnectionInfo.DatabaseName} of {companies.Count()}");
        try
        {
            DateTime startDate = company.SyncData.LastPatientSyncDate.HasValue ? company.SyncData.LastPatientSyncDate.Value : company.UpdoxSyncData.CurrentDatabaseDate.AddYears(-3);

            var data = await databaseHelper.GetPatientsForCompanyAsync(company, startDate);
            logger.LogInformation($"Company: {company.ConnectionInfo.DatabaseName} - Loaded: {data.Count()} Patients");
            var manager = new ContentManager(company, appConfiguration);
            var responses = await manager.PostEntityData("patients", appConfiguration.PatientUrl, data.Select(x => new
            {
                id = x.patient_id.ToString(),
                internalId = x.patient_id.ToString(),
                firstName = x.first_name,
                middleName = x.middle_name,
                lastName = x.last_name,
                emailAddress = x.email,
                homePhone = x.HomePhone, 
                mobileNumber = x.OtherPhone,
                communicationConsent = ((Func<Array>)(() =>
                {
                    var list = new List<object>();
                    if (x.TextConsent)
                        list.Add(new { method = "TEXT", consent = true });

                    if (x.VoiceConsent)
                        list.Add(new { method = "VOICE", consent = true });

                    if (x.EmailConsent)
                        list.Add(new { method = "EMAIL", consent = true });

                    return list.ToArray();
                }))()
            }));

            if (responses.All(x => x.IsSuccessStatusCode))
                await databaseHelper.SavePatientLastUpdatedDateForCompany(company, company.SyncData.CurrentDatabaseDate);
            else
                throw new DataException($"Response for SyncPatientData failed for {company.ConnectionInfo.DatabaseName}");
        }
        catch (Exception ex)
        {
            logger.LogError($"Database: {company.ConnectionInfo.DatabaseName} Method: SyncPatientData", ex);
        }
    }
}

为优化代码结构，我尝试将.Select中的转换逻辑提取为独立变量或方法，但始终收到错误提示："带有语句体的lambda表达式无法转换为表达式树"。我尝试过的部分实现如下：

readonly Expression<Func<Patient, object>> patientSelect = x => {
    id = x.patient_id.ToString(),
                internalId = x.patient_id.ToString(),
                firstName = x.first_name,
                middleName = x.middle_name,
                lastName = x.last_name,
                emailAddress = x.email,
                homePhone = x.HomePhone, 
                mobileNumber = x.OtherPhone,
                communicationConsent = ((Func<Array>)(() =>
                {
                    var list = new List<object>();
                    if (x.TextConsent)
                        list.Add(new { method = "TEXT", consent = true });

                    if (x.VoiceConsent)
                        list.Add(new { method = "VOICE", consent = true });

                    if (x.EmailConsent)
                        list.Add(new { method = "EMAIL", consent = true });

                    return list.ToArray();
                }))()
            }));;

private Expression<Func<Patient, dynamic>> patientSelectE(Patient p)
{
    return p => new  
    {
        id = p.patient_id.ToString(),
        internalId = p.patient_id.ToString(),
        firstName = p.first_name,
        middleName = p.middle_name,
        lastName = p.last_name,                 
        emailAddress = p.email,
        homePhone = p.HomePhone,
        mobileNumber = p.OtherPhone, 
        communicationConsent = ((Func<Array>)(() =>
        {
            var list = new List<object>();
            if (p.TextConsent)
                list.Add(new { method = "TEXT", consent = true });

            if (p.VoiceConsent)
                list.Add(new { method = "VOICE", consent = true });

            if (p.EmailConsent)
                list.Add(new { method = "EMAIL", consent = true });

            return list.ToArray();
        })) 
    });
}

最终需要序列化为符合以下格式的JSON请求体：

{
 "patients": [
{
  "firstName": "John",
  "middleName": "Q",
  "lastName": "EveryMan",
  "emailAddress": "test@test.com",
  "homePhone": "555-555-5555",
  "workPhone": "555-555-5555",
  "mobileNumber": "555-555-5555", 

  "communicationConsent": [
    {
      "method": "EMAIL",
      "consent": "true"
    },
    {
      "method": "TEXT",
      "consent": "true"
    },
    {
      "method": "VOICE",
      "consent": "true"
    }
  ]
}
]
}

原因分析 #

问题核心在于Lambda表达式的两种编译目标差异：

• 内联使用时，data是Dapper返回的IEnumerable<Patient>，对应的Select方法接受Func<Patient, T>委托。编译器会将Lambda编译为委托，而委托支持带有语句体的Lambda（比如内部的if判断、列表创建逻辑）。
• 当手动声明为Expression<Func<Patient, object>>时，编译器需要将Lambda转换为表达式树，但表达式树仅支持纯表达式（无语句体，不能包含if、变量声明等流程控制语句），这就是报错的根源。

解决方案 #

方案1：使用委托而非表达式树 #

直接将转换逻辑声明为Func<Patient, object>委托，同时把communicationConsent的逻辑抽成独立方法，让代码更清晰：

// 定义转换委托
private readonly Func<Patient, object> _patientToApiModel = x => new
{
    id = x.patient_id.ToString(),
    internalId = x.patient_id.ToString(),
    firstName = x.first_name,
    middleName = x.middle_name,
    lastName = x.last_name,
    emailAddress = x.email,
    homePhone = x.HomePhone,
    mobileNumber = x.OtherPhone,
    communicationConsent = BuildCommunicationConsent(x)
};

// 抽离通信许可逻辑
private static object[] BuildCommunicationConsent(Patient patient)
{
    var consentList = new List<object>();
    if (patient.TextConsent)
        consentList.Add(new { method = "TEXT", consent = true });
    if (patient.VoiceConsent)
        consentList.Add(new { method = "VOICE", consent = true });
    if (patient.EmailConsent)
        consentList.Add(new { method = "EMAIL", consent = true });
    return consentList.ToArray();
}

使用时直接传入委托即可：

var responses = await manager.PostEntityData("patients", appConfiguration.PatientUrl, data.Select(_patientToApiModel));

方案2：（可选）显式声明DTO类 #

如果后续需要扩展或复用这个模型，建议显式声明一个DTO类，代替匿名类型，代码可读性和可维护性会更好：

public class PatientApiDto
{
    public string id { get; set; }
    public string internalId { get; set; }
    public string firstName { get; set; }
    public string middleName { get; set; }
    public string lastName { get; set; }
    public string emailAddress { get; set; }
    public string homePhone { get; set; }
    public string mobileNumber { get; set; }
    public List<CommunicationConsent> communicationConsent { get; set; } = new();
}

public class CommunicationConsent
{
    public string method { get; set; }
    public bool consent { get; set; }
}

// 转换方法
private PatientApiDto MapToPatientApiDto(Patient patient)
{
    var dto = new PatientApiDto
    {
        id = patient.patient_id.ToString(),
        internalId = patient.patient_id.ToString(),
        firstName = patient.first_name,
        middleName = patient.middle_name,
        lastName = patient.last_name,
        emailAddress = patient.email,
        homePhone = patient.HomePhone,
        mobileNumber = patient.OtherPhone
    };

    if (patient.TextConsent)
        dto.communicationConsent.Add(new CommunicationConsent { method = "TEXT", consent = true });
    if (patient.VoiceConsent)
        dto.communicationConsent.Add(new CommunicationConsent { method = "VOICE", consent = true });
    if (patient.EmailConsent)
        dto.communicationConsent.Add(new CommunicationConsent { method = "EMAIL", consent = true });

    return dto;
}

使用时：

var responses = await manager.PostEntityData("patients", appConfiguration.PatientUrl, data.Select(MapToPatientApiDto));

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