LINQ (Max) avec des valeurs Null

J'ai une liste qui contient un tas de Points (avec un X et la composante Y).

Je veux obtenir le Max X pour tous les points dans la liste, comme ceci:

double max = pointList.Max(p=> p.X);

Le problème, c'est quand j'ai une valeur null dans la liste au lieu d'un point. Quelle serait la meilleure façon de contourner ce problème?

InformationsquelleAutor Jason | 2011-02-18

c#linq

105

Eh bien, vous pourriez juste filtrent:
```
pointList.Where(p => p != null).Max(p => p.X)
```
D'autre part, si vous voulez nulls à être traitées comme si elles étaient les points ayant coordonnée X 0 (ou similaire), vous pourriez faire:
```
pointList.Max(p => p == null ? 0 : p.X)
```
Ne remarque que les deux techniques vont se jeter, si la séquence est vide. Une solution de contournement pour ce (si souhaité) serait:
```
pointList.DefaultIfEmpty().Max(p => p == null ? 0 : p.X)
```
- Parfait - Merci
- Je ne recommanderais pas à l'aide de la DefaultIfEmpty. Merci de regarder ma réponse quant à pourquoi: lien
- Je crois que c'est une requête LINQ de mémoire entités, sans une connexion à une base de données.
- si c'est le cas, alors soit est très bien 🙂 Mais maintenant ppl ne savent pas l'utiliser pour LinqToSql.
- Ou plutôt: Linq to entities.
- Il pourrait aussi utiliser un type nullable, pointList.Max(p => p == null ? (double?)null : p.X) si il le voulait. Notez que les types nullables Max ne va rien faire, même pas avec une séquence vide.
- Ou moins: pointList.DefaultIfEmpty().Max(p => p.X ?? 0)
InformationsquelleAutor Ani
26

Si vous souhaitez fournir une valeur par défaut pour les X d'un point nul:
```
pointList.Max(p => p == null ? 0 : p.X)
```
Ou pour fournir une valeur par défaut pour la liste vide:
```
int max = points.Where(p => p != null)
                .Select(p => p.X)
                .DefaultIfEmpty()
                .Max();
```
- Approche intéressante, je l'aime mieux que la mienne, parce qu'il évite le conditionnel et le DefaultIfEmpty est appliqué sur le résultat type.
InformationsquelleAutor Mark Byers
14

Je ne recommanderais pas à l'aide de la DefaultIfEmpty dans ce cas, car il produit un assez grand SQL par rapport à d'autres alternatives.

Veuillez jeter un oeil à cet exemple:

Nous avons une liste de modules pour une page et que vous souhaitez obtenir le maximum de valeur de la colonne "Type". Si la liste ne comporte aucun enregistrement, la valeur null est retournée. DefaultIfEmpty vérifie null et retourne la valeur par défaut du type de données de colonne lorsque la colonne est null.
```
var max = db.PageModules.Where(t => t.PageId == id).Select(t => t.Sort).DefaultIfEmpty().Max();
```
Ce produit le SQL suivant:
```
exec sp_executesql N'SELECT 
[GroupBy1].[A1] AS [C1]
FROM ( SELECT 
    MAX([Join1].[A1]) AS [A1]
    FROM ( SELECT 
        CASE WHEN ([Project1].[C1] IS NULL) THEN 0 ELSE [Project1].[Sort] END AS [A1]
        FROM   ( SELECT 1 AS X ) AS [SingleRowTable1]
        LEFT OUTER JOIN  (SELECT 
            [Extent1].[Sort] AS [Sort], 
            cast(1 as tinyint) AS [C1]
            FROM [dbo].[PageModules] AS [Extent1]
            WHERE [Extent1].[PageId] = @p__linq__0 ) AS [Project1] ON 1 = 1
    )  AS [Join1]
)  AS [GroupBy1]',N'@p__linq__0 int',@p__linq__0=11
go
```
Si nous à la place de fonte de la colonne à une nullable et laissez Convert.ToInt32() gérer la valeur null comme:
```
var max = Convert.ToInt32(db.PageModules.Where(t => t.PageId == id).Max(t => (int?)t.Sort));
```
Alors nous obtenons le code SQL suivant:
```
exec sp_executesql N'SELECT 
[GroupBy1].[A1] AS [C1]
FROM ( SELECT 
    MAX([Extent1].[Sort]) AS [A1]
    FROM [dbo].[PageModules] AS [Extent1]
    WHERE [Extent1].[PageId] = @p__linq__0
)  AS [GroupBy1]',N'@p__linq__0 int',@p__linq__0=11
go
```
Je peux vraiment recommander à l'aide de ExpressProfiler pour la vérification de la requête SQL est exécutée:
http://expressprofiler.codeplex.com/

La dernière expression Linq peut aussi être écrit comme:
```
var max = Convert.ToInt32(db.PageModules.Where(t => t.PageId == id).Select(t => (int?)t.Sort).Max());
```
et produira les mêmes SQL, mais j'aime le plus concis .Max(t => (int?)t.Sort).
- Le problème avec un ORM ou un outil qui génère le SQL pour vous est que c'est tellement facile de se tirer dans le pied. Tous vous face à l'est du code et que presque personne ne regarde le SQL généré. Problème avec ces mécaniques des traductions, c'est qu'ils produisent des "One size fits all" code et parfois, il est plus grand que ce que vous pourriez avoir besoin. Merci pour mettre en évidence que dans ce post. Bas de ligne, vérifiez toujours vos requêtes générées! +1!!
- +1 pour vérifiez toujours vos requêtes générées! Vous pouvez écrire un mauvais SQL (afin de profil), mais en quelque sorte l'ORM obtient toujours les blâmer quand on n'a pas le profil (ou même de le regarder) le SQL, il génère!
- Je suis en train d'utiliser cette méthode, mais j'ai une autre syntaxe de requête donc je ne peux pas sembler obtenir le lamda expression dans le sélectionner pour le travail. Je suis à l'aide de Convert.ToInt32( (from x in table join y in table 2 on x.ID equals y.ID where y.ProjectID == ProjectID select x.ObservationNum).Max()); Est-il un moyen de faire le joint avec votre syntaxe, ou de modifier ma méthode pour arriver à la nullable int cast?
- Du haut de ma tête, essayez ".Max(t => (int?)t.Trier)".
- Doh . . . et c'est là, dans votre réponse . . . merci 🙂
InformationsquelleAutor Nikkelmann

double max = pointList.Where(p=>p != null).Max(p=>p.X)

Devrait fonctionner.

InformationsquelleAutor Robaticus

1

Place nullable coulé à l'INTÉRIEUR de l'expression afin de s'assurer qu'une liste vide sera jeté comme une valeur null. Vous pouvez ensuite ajouter des valeurs par défaut.
```
double max = pointList.Max(p=>(double?)p.X) ?? 0;
```
InformationsquelleAutor Carter Medlin
0

Essayer de casting pour nullable
```
double max = (double?)pointList.Max(p => p.X);
```
plus:
Max ou par Défaut?

InformationsquelleAutor Petr

Pourquoi ne pas tout simplement:

double? maxOrNull  = pointList.
    .Where(p => p != null)
        .OrderByDescending(p => p.x)
        .FirstOrDefault();
double max = 0;
if (maxOrNull.HasValue) max = maxOrNull.Value;

Cela fonctionne avec de la mémoire de listes et Linq2Sql, et probablement de manière efficace aussi.

InformationsquelleAutor Kerneels Roos

0

Nullable colonne avec max est comme suit
```
var maximum = objectEntity.where(entity => entity.property != null).max(entity => entity.property.HasValue);
```
Ci-dessus énoncé de retour nombre maximal de propriété d'entité

InformationsquelleAutor Niraj Trivedi

Vous devez vous connecter pour publier un commentaire.