L'Inférence de Type a échoué dans un appel à "rejoindre" sur les valeurs null et non nullable int

Dans mon Linq, je suis en train de faire une jointure interne à nullable champ. L'employé et le Département ont un rapport, le Ministère peut avoir un Employé ou peuvent avoir une valeur null. Donc, ce serait ma le rejoindre, si je veux uniquement les enregistrements qui satisfait la jointure interne (pas de résultat pour null EmployeeIDs):

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

Je suis une exception:

Le type de l'une des expressions de la clause de jointure est incorrect.
L'Inférence de Type a échoué dans un appel à "rejoindre".

Grâce

OriginalL'auteur manav inder | 2011-09-08

c#entity-framework linq non-nullable nullable

9

Que si vous annulez votre rejoindre et de mettre un peu where là?
```
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 };
```
Comment pourrait-il même suppose de travailler, encore emp.EmployeeID est un non nullable champ et dept.EmployeeID est nullable champ, j'ai même vérifier votre code, mais pas de chance, Toujours la même erreur. Nous ne pouvons pas nous rejoindre nullable int int
vous avez besoin de changer dept.Employé dans le dept.EmployeeID.Valeur
Si votre code est différent de un ici ideone.com/4F8X2? Je suppose que cela doit être, puisque vous obtenez l'erreur.
À partir du lien que vous avez donné, je suis tellement débordé, je n'ai pas de mots pour dire MERCI, Vous êtes tout simplement exceptionnel, Il y a une différence entre ce code et le un ont écrit dans ce lien, en tout cas un GRAND MERCI
Ce n'est qu'un conseil: pourquoi avez-vous utilisé "à nouveau" et "équivaut à nouveau", pour un simple comparateur, vous n'avez pas besoin d'utiliser l'instruction "nouvelle", des "on" et "égaux", on department.EmployeeID.Value equals employee.EmployeeID

OriginalL'auteur Asbjørn Ulsberg

De comparer les Int? et Int, ajouter .Value à la nullable propriété:

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

OriginalL'auteur Greg Sansom

1

Vérifier le type sur emp.EmployeeID et dept.EmployeeID. Vous pourriez être absent un casting si elles sont différentes.

quelque chose comme:
```
on new { Source = emp.EmployeeID }
equals new { Source = **(int)**dept.EmployeeID };
```
Ressemble emp.EmployeeID est de type int et dept.EmployeeID est de type nullable<int>.

OriginalL'auteur devendar r mandala

J'ai eu le même problème, d'où mon charge_codes.CompanyId était nullable mais mon order_items.CompanyId n'était PAS les valeurs null.

Donc j'ai dû mettre mes codes de charges dans leur propre ananomous type et de faire ne pas accepter les valeurs null.

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}

Merci!!!! J'ai eu un problème similaire où le champ id est un varchar dans un tableau et dans d'autres. La conversion des anomalies de type fixe.

OriginalL'auteur emomon23

1

Trouvé une réponse utile à partir d'un autre lien à https://social.msdn.microsoft.com/Forums/en-US/bf98ec7a-cb80-4901-8eb2-3aa6636a4fde/linq-join-error-the-type-of-one-of-the-expressions-in-the-join-clause-is-incorrect-type-inference?forum=linqprojectgeneral

À se joindre à valeurs multiples touches dont vous avez besoin pour construire un anonyme typ sur les deux côtés de l '"égal à égal", qui est le même type. L'anonyme de type initialiseur d'expression implique à la fois le type et le nom des membres de l'expression que vous fournissez. Dans votre cas, les noms des membres sont différentes, donc les types finissent par être différent des autres et C# ne peut pas trouver le type le plus commun entre les deux.

sur les nouveaux { CR.Faire, VC.Modèle } est égal à new { MD.MakeID, MD.RefNum }

devrait être

sur les nouveaux { CR.Faire, CV.Modèle } est égal à new { Marque = MD.MakeID, Modèle = MD.RefNum }

À l'aide de la syntaxe nom = valeur dans l'initialiseur, vous pouvez spécifier le nom du compilateur utilise lors de la création de ce type. Si tous les types de membres & les noms sont les mêmes, puis les types anonymes sont du même type.

OriginalL'auteur teapeng
0

Dans mon scénario, j'ai eu cette erreur sur une jointure à l'aide de plusieurs colonnes. Les noms des propriétés sont différentes et l'un d'eux a également été nullable. Tous les je ne a été la création d'un nom à ces propriétés et en ajoutant le ".Valeur" sur le nullable valeur, de sorte que le LINQ participer pourrait associer correctement ces propriétés.
```
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 }
```
J'espère que cela aide celui qui est en face de cette question.

OriginalL'auteur nilsonam

Vous devez vous connecter pour publier un commentaire.