La inferencia de tipo falló en una llamada a 'unirse' en intes anulables y no anulables

Question

En mi Linq, estoy tratando de hacer una unión interior a un campo anulable. El empleado y el departamento tienen una relación, el departamento puede tener un empleado o puede tener un nulo. Entonces, ¿cuál sería mi unión? Si solo quiero los registros que satisfacen la unión interna (sin resultado para los empleados nulos):

var result = from emp in employees
             join dept in departments
             on new { Source = emp.EmployeeID }
             equals new { Source = dept.EmployeeID };

Estoy recibiendo una excepción:

El tipo de una de las expresiones en la cláusula de unión es incorrecto. Tipo La inferencia falló en una llamada a 'unirse'.

Gracias

Answer 1

¿Qué pasa si revierte su unión y pones un poco? where ¿ahí?

var result = from department in departments
             where department.EmployeeID != null
             join employee in employees
             on department.EmployeeID.Value equals employee.EmployeeID
             select new { employee, department };

Answer 2

Para comparar int? e int, agregar .Value a la propiedad anulable:

var result = from emp in employees
             join dept in departments
             on new { Source = emp.EmployeeID }
             equals new { Source = dept.EmployeeID.Value };

Answer 3

Verifique el tipo en emp.EmployeeID y dept.EmployeeID. Es posible que te falta un elenco si son diferentes.

algo como:

on new { Source = emp.EmployeeID }
equals new { Source = **(int)**dept.EmployeeID };

Parece emp.EmployeeID es de tipo int y dept.EmployeeID es de tipo nullable<int>.

Answer 4

Tuve el mismo problema, donde mi Charge_Codes.comPanyid era anulable, pero mi orden_items.companyid no era anulable.

Así que tuve que poner mis códigos de carga en su propio tipo ananómico y hacer que no sea anulable.

var chargeCodes = from s in db.Charge_Codes
where s.CompanyID != null
select new { CompanyID = (int)s.CompanyID, 
             Charge_CodeID = s.Charge_CodeID, 
             Revenue_Code_Id = (int)s.Revenue_CodeID, };



//now my chargeCodes contains an anonymous with a non nullable CompanyID and 
//a non nullable Revenue_CodeID 

//use chargeCodes here
var query = from oi in db.Order_Items
join cc in chargeCodes on 
new {oi.CompanyID, oi.Charge_CodeID} equals new {cc.CompanyID, cc.Charge_CodeID}

Answer 5

Encontró una respuesta útil de otro enlace en https://social.msdn.microsoft.com/forums/en-us/bf98ec7a-cb80-4901-8eb2-3aa6636a4fde/linq-join-error-the-type-of-one-of-the-expresions-in- The-Join-cláusula-is-incorrecto-inferencia?

Para unir las claves de valor múltiple, debe construir un típido anónimo en ambos lados de los 'iguales' que es del mismo tipo. La expresión de inicializador de tipo anónimo infiere tanto el tipo como el nombre de los miembros de la expresión que proporciona. En su caso, los nombres de los miembros son diferentes, por lo que los tipos terminan siendo diferentes, por lo que C# no puede descubrir el tipo común entre los dos.

en nuevo {vc.make, vc.model} es igual a nuevo {md.makeid, md.refnum}

debiera ser

en nuevo {vc.make, cv.model} es igual a nuevo {make = md.makeid, model = md.refnum}

Usando la sintaxis Name = Value en el inicializador, puede especificar el nombre que usa el compilador al crear el tipo. Si todos los tipos y nombres de miembros son los mismos, los tipos anónimos son del mismo tipo.

Answer 6

En mi escenario tuve este error en una unión usando varias columnas. Los nombres de las propiedades eran diferentes y uno de ellos también era anulable. Todo lo que hice fue crear un nombre a esas propiedades y agregar el "valor" en el valor anulable para que la unión LINQ pudiera asociar correctamente esas propiedades.

var query = from y in Context.Table1
        join y in Context.Table2 on new { Field1 = x.Field1.Value, Field2 = x.Field2 }
        equals new { Field1 = y.Field1DiffName, Field2 = y.Field2 }

Espero que ayude a quien se enfrente a este problema.