"Impossible de convertir l'expression lambda en type" bool "car ce n'est pas un type de délégué" avec Lazy <T>

Question

Il y a beaucoup de questions là-bas qui ont cette erreur, mais c'est parce qu'il semble être une erreur commune qui se produit avec lambdas dans de nombreux scénarios; Cependant, je ne peux pas déterminer la raison de mon problème.

J'utilise Lazy et cela fonctionne très bien:

/// <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; 
} 

est ici EmployeeLoading.LoadEmployee juste pour la référence:

/// <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; 
} 

Maintenant, quand je fais quelque chose de similaire:

/// <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; 
} 

I Je reçois une erreur sur le lambda () => GetEmployeeWorksiteUserName(employee):

ne peut pas convertir l'expression lambda de type 'bool' parce qu'il est pas un type de délégué

est ici GetEmployeeWorksiteUserName pour référence:

/// <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; 
    } 
} 

Je crois que le compilateur pense que je suis en train d'appeler le constructeur pour Lazy<T> qui prend bool seul, mais il est bien documenté que mon approche devrait fonctionner (voir des sites comme this, par exemple).

Pourquoi cette approche fonctionne très bien dans le premier cas et obtenir l'erreur dans le second cas? Comment je le répare?

Answer 1

C'est parce que vous utilisez le employee avant qu'il ne soit été déclarée (efficace dans le constructeur).

Notez la différence:

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

Answer 2

J'ai essayé de reproduire votre problème, mais je reçois des erreurs du compilateur parce que je ne suis pas en mesure d'utiliser la référence des employés avant qu'il ne soit déclaré. Pouvez-vous essayer de le faire de cette façon pour vérifier si cela résout votre problème?

/// <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; 
}