“无法将 lambda 表达式转换为类型 'bool'，因为它不是委托类型”与 Lazy<T>

Question

有很多问题都有这个错误，但那是因为它似乎是 lambdas 在许多情况下发生的常见错误；但是，我无法确定问题的原因。

我正在使用 Lazy 并且效果很好：

/// <summary>
/// Build a client from the provided data entity.
/// </summary>
/// <param name="fromDataEntity">The data entity from which the client will be built.</param>
/// <returns>The data entity that is built.</returns>
private static Client BuildClient(ClientDataEntity fromDataEntity)
{
    var client = new Client()
    {
        ClientCode = fromDataEntity.ClientCode,
        Name = fromDataEntity.Name,
        BillingAttorneyLazy = new Lazy<Employee>(() => EmployeeLoading.LoadEmployee(fromDataEntity.BillingAttorneyEmployeeUno))
    };

    return client;
}

这里EmployeeLoading.LoadEmployee仅供参考：

/// <summary>
/// Load the employee, if it exists, with the provided employee uno.
/// </summary>
/// <param name="withEmployeeUno">The employee uno for the employee that will be loaded.</param>
/// <returns>The employee that is loaded, if one exists for the provided uno, or else null.</returns>
internal static Employee LoadEmployee(uint withEmployeeUno)
{
    var entity = CmsDataAbstraction.GetEmployeeDataEntity(withEmployeeUno);
    return (entity != null) ? BuildEmployee(entity) : null;
}

现在，当我做类似的事情时：

/// <summary>
/// Build and return an employee from the provided data entity.
/// </summary>
/// <param name="fromDataEntity">The data entity from which the employee will be built.</param>
/// <returns>Build and return an employee from the provided data entity.</returns>
private static Employee BuildEmployee(EmployeeDataEntity fromDataEntity)
{
    var employee = new Employee()
    {
        EmployeeCode = fromDataEntity.Code,
        WorksiteUserNameLazy = new Lazy<string>(() => GetEmployeeWorksiteUserName(employee))
    };

    return employee;
}

我在 lambda () => GetEmployeeWorksiteUserName(employee) 上遇到错误：

无法将 lambda 表达式转换为类型“bool”，因为它不是 委托类型

这里是GetEmployeeWorksiteUserName供参考：

/// <summary>
/// Retrieve the Worksite username for the provided employee.
/// </summary>
/// <param name="forEmployee">The employee whose Worksite username will be retrieved.</param>
/// <returns>The Worksite username for the associated employee.</returns>
private static string GetEmployeeWorksiteUserName(Employee forEmployee)
{
    var authorADAccountName = FirmInformationDataAbstraction.GetEmployeeActiveDirectoryUsername(forEmployee.EmployeeCode);

    if (WorksiteDataAbstraction.UserExists(authorADAccountName))
    {
        return authorADAccountName;
    }
    else // user doesn't exist in Worksite.
    {
        return string.Empty;
    }
}

我相信编译器认为我正在尝试调用 Lazy<T> 的构造函数，它需要一个 bool，但有据可查的是，我的方法应该可以工作（例如，参见 this 之类的网站）。

为什么这种方法在第一种情况下运行良好，而在第二种情况下出现错误？我该如何解决？

Answer 1

这是因为您在声明之前使用了employee（有效地在构造函数中）。

注意区别：

var employee = new Employee()
{
    EmployeeCode = fromDataEntity.Code
};
employee.WorksiteUserNameLazy = 
    new Lazy<string>(() => GetEmployeeWorksiteUserName(employee));

Answer 2

我已尝试重现您的问题，但出现编译器错误，因为我无法在声明之前使用员工参考。您可以尝试这样做以检查它是否解决了您的问题吗？

/// <summary>
/// Build and return an employee from the provided data entity.
/// </summary>
/// <param name="fromDataEntity">The data entity from which the employee will be built.</param>
/// <returns>Build and return an employee from the provided data entity.</returns>
private static Employee BuildEmployee(EmployeeDataEntity fromDataEntity)
{
    var employee = new Employee()
    {
        EmployeeCode = fromDataEntity.Code            
    };
    employee.WorksiteUserNameLazy = new Lazy<string>(() => GetEmployeeWorksiteUserName(employee));
    return employee;
}