Comment pouvez-j'ai une requête pour des valeurs nulles dans le cadre de l'entité?

Solution de contournement pour Linq-to-SQL:

var result = from entry in table
             where entry.something.Equals(value)
             select entry;

Solution de contournement pour Linq-to-Entités (aïe!):

var result = from entry in table
             where (value == null ? entry.something == null : entry.something == value)
             select entry;

C'est un méchant bug qui m'a mordu à plusieurs reprises. Si ce bug a affecté vous aussi, veuillez visiter le rapport de bug sur UserVoice et permettre à Microsoft de savoir que ce bug a touché vous-même.

---

Edit: Ce bug est en cours de correction en EF 4.5! Merci à tous pour upvoting ce bug!

Pour la compatibilité ascendante, il sera opt-dans - vous besoin d'activer manuellement un réglage à faire entry == value travail. Aucun mot encore sur ce réglage. Restez à l'écoute!

---

Edit 2: Selon ce post par l'équipe EF, ce problème a été corrigé dans EF6! Woohoo!

Nous avons changé le comportement par défaut de EF6 pour compenser logique tri-valuée.

Cela signifie que le code existant qui repose sur l'ancien comportement (null != null, mais seulement lorsque l'on compare à une variable) devront soit être changé de ne pas s'appuyer sur ce comportement, ou un ensemble UseCSharpNullComparisonBehavior à false pour utiliser l'ancien comportement défectueux.

Il est un peu plus simple solution de contournement qui fonctionne avec LINQ to entities:

var result = from entry in table
         where entry.something == value || (value == null && entry.something == null)
         select entry;

Cela fonctionne becasuse, comme AZ remarqué, LINQ to entities cas spéciaux x == null (c'est à dire une comparaison d'égalité contre la constante null) et la convertit en x EST NULLE.

Nous envisageons actuellement de modifier ce comportement pour introduire la compensation des comparaisons automatiquement si les deux côtés de l'égalité sont des valeurs null. Il ya un couple de défis:

1. Cela pourrait briser le code qui dépend déjà du comportement existant.
2. La nouvelle traduction pourrait affecter les performances de requêtes existantes, même lorsqu'un paramètre null est rarement utilisé.

Dans tous les cas, si nous arrivons à travailler sur cela va dépendre grandement de la priorité relative accordée à nos clients de lui attribuer. Si vous vous souciez de la question, je vous encourage à voter pour elle dans notre nouvelle Fonctionnalité de Suggestion de site: https://data.uservoice.com.

var result = from entry in table
             where entry.something.Equals(null)
             select entry;

Référence MSDN: LINQ to SQL: .NET Language-Integrated Query de Données Relationnelles

De noter que toutes les Entity Framework < 6.0 suggestions générer certains maladroits SQL. Voir le deuxième exemple pour "nettoyer" fix.

Ridicule Solution De Contournement

//comparing against this...
Foo item = ...

return DataModel.Foos.FirstOrDefault(o =>
    o.ProductID == item.ProductID
    //ridiculous < EF 4.5 nullable comparison workaround http://stackoverflow.com/a/2541042/1037948
    && item.ProductStyleID.HasValue ? o.ProductStyleID == item.ProductStyleID : o.ProductStyleID == null
    && item.MountingID.HasValue ? o.MountingID == item.MountingID : o.MountingID == null
    && item.FrameID.HasValue ? o.FrameID == item.FrameID : o.FrameID == null
    && o.Width == w
    && o.Height == h
    );

résultats dans SQL comme:

SELECT TOP (1) [Extent1].[ID]                 AS [ID],
[Extent1].[Name]               AS [Name],
[Extent1].[DisplayName]        AS [DisplayName],
[Extent1].[ProductID]          AS [ProductID],
[Extent1].[ProductStyleID]     AS [ProductStyleID],
[Extent1].[MountingID]         AS [MountingID],
[Extent1].[Width]              AS [Width],
[Extent1].[Height]             AS [Height],
[Extent1].[FrameID]            AS [FrameID],
FROM   [dbo].[Foos] AS [Extent1]
WHERE  (CASE
WHEN (([Extent1].[ProductID] = 1 /* @p__linq__0 */)
AND (NULL /* @p__linq__1 */ IS NOT NULL)) THEN
CASE
WHEN ([Extent1].[ProductStyleID] = NULL /* @p__linq__2 */) THEN cast(1 as bit)
WHEN ([Extent1].[ProductStyleID] <> NULL /* @p__linq__2 */) THEN cast(0 as bit)
END
WHEN (([Extent1].[ProductStyleID] IS NULL)
AND (2 /* @p__linq__3 */ IS NOT NULL)) THEN
CASE
WHEN ([Extent1].[MountingID] = 2 /* @p__linq__4 */) THEN cast(1 as bit)
WHEN ([Extent1].[MountingID] <> 2 /* @p__linq__4 */) THEN cast(0 as bit)
END
WHEN (([Extent1].[MountingID] IS NULL)
AND (NULL /* @p__linq__5 */ IS NOT NULL)) THEN
CASE
WHEN ([Extent1].[FrameID] = NULL /* @p__linq__6 */) THEN cast(1 as bit)
WHEN ([Extent1].[FrameID] <> NULL /* @p__linq__6 */) THEN cast(0 as bit)
END
WHEN (([Extent1].[FrameID] IS NULL)
AND ([Extent1].[Width] = 20 /* @p__linq__7 */)
AND ([Extent1].[Height] = 16 /* @p__linq__8 */)) THEN cast(1 as bit)
WHEN (NOT (([Extent1].[FrameID] IS NULL)
AND ([Extent1].[Width] = 20 /* @p__linq__7 */)
AND ([Extent1].[Height] = 16 /* @p__linq__8 */))) THEN cast(0 as bit)
END) = 1

---

Scandaleux Solution De Contournement

Si vous voulez générer plus propre SQL, quelque chose comme:

//outrageous < EF 4.5 nullable comparison workaround http://stackoverflow.com/a/2541042/1037948
Expression<Func<Foo, bool>> filterProductStyle, filterMounting, filterFrame;
if(item.ProductStyleID.HasValue) filterProductStyle = o => o.ProductStyleID == item.ProductStyleID;
else filterProductStyle = o => o.ProductStyleID == null;
if (item.MountingID.HasValue) filterMounting = o => o.MountingID == item.MountingID;
else filterMounting = o => o.MountingID == null;
if (item.FrameID.HasValue) filterFrame = o => o.FrameID == item.FrameID;
else filterFrame = o => o.FrameID == null;
return DataModel.Foos.Where(o =>
o.ProductID == item.ProductID
&& o.Width == w
&& o.Height == h
)
//continue the outrageous workaround for proper sql
.Where(filterProductStyle)
.Where(filterMounting)
.Where(filterFrame)
.FirstOrDefault()
;

résultats dans ce que tu voulais en premier lieu:

SELECT TOP (1) [Extent1].[ID]                 AS [ID],
[Extent1].[Name]               AS [Name],
[Extent1].[DisplayName]        AS [DisplayName],
[Extent1].[ProductID]          AS [ProductID],
[Extent1].[ProductStyleID]     AS [ProductStyleID],
[Extent1].[MountingID]         AS [MountingID],
[Extent1].[Width]              AS [Width],
[Extent1].[Height]             AS [Height],
[Extent1].[FrameID]            AS [FrameID],
FROM   [dbo].[Foos] AS [Extent1]
WHERE  ([Extent1].[ProductID] = 1 /* @p__linq__0 */)
AND ([Extent1].[Width] = 16 /* @p__linq__1 */)
AND ([Extent1].[Height] = 20 /* @p__linq__2 */)
AND ([Extent1].[ProductStyleID] IS NULL)
AND ([Extent1].[MountingID] = 2 /* @p__linq__3 */)
AND ([Extent1].[FrameID] IS NULL)

Il semble que Linq2Sql a ce "problème" ainsi. Il semble qu'il y a une raison valable à ce problème en raison de si ANSI Null ou non, mais cela dépasse l'entendement pourquoi un droit "== null" sera en fait le travail comme vous le souhaitez.

Je ne suis pas en mesure de commenter divega post, mais parmi les différentes solutions présentées ici, divega la solution de produit le meilleur SQL. Performance sage et la longueur de la sagesse. Je viens de vérifier avec le générateur de profils SQL Server et en regardant le plan d'exécution (avec "DÉFINIR le PROFIL de STATISTIQUES SUR l'").

Si vous préférez l'aide de la méthode (lambda) de la syntaxe comme je le fais, vous pourriez faire la même chose comme ceci:

var result = new TableName();
using(var db = new EFObjectContext)
{
var query = db.TableName;
query = value1 == null 
? query.Where(tbl => tbl.entry1 == null) 
: query.Where(tbl => tbl.entry1 == value1);
query = value2 == null 
? query.Where(tbl => tbl.entry2 == null) 
: query.Where(tbl => tbl.entry2 == value2);
result = query
.Select(tbl => tbl)
.FirstOrDefault();
//Inspect the value of the trace variable below to see the sql generated by EF
var trace = ((ObjectQuery<REF_EQUIPMENT>) query).ToTraceString();
}
return result;