De retour à zéro pour Count() sur la valeur null IEnumerables

Je suis fatigué d'utiliser le code comme ceci:

var count = 0;
if (myEnumerable != null)
{
    count = myEnumerable.Count();
}

Et c'est un peu pédant:

var count = (myEnumerable ?? new string[0]).Count();

Est-il plus propre façon de faire cela? Une fois, j'ai eu la (mal nommée) PhantomCount méthode d'extension sur IEnumerable<> qui a utilisé mon premier exemple de code, mais il avait quelque chose de l'odeur sur elle (en plus le nom).

InformationsquelleAutor ProfK | 2010-08-19

.net c#collections

32

Le problème est vraiment dans tout ce qui est de la création de ces enumerables. Sauf si vous avez une très bonne raison, tout ce qui génère un objet iterable collection doit retourner un vide de la collection au lieu de null. Cela permettrait d'harmoniser avec la Null-Objet-Modèle, d'où les avantages sont les mêmes.

Ma suggestion serait de réparer ce produit myEnumerable, ou si vous ne pouvez pas faire cela, d'ajouter une case façon plus tôt pour voir si elle est nulle et de réagir de façon appropriée.
- +1 pour le diagnostic de la cause de racine
- Avoir un autre +1. Il est vraiment de bonne pratique lors de la conception d'une API pour les retours à vide des collections plutôt que les valeurs null pour éviter d'imposer un fardeau sur les développeurs à faire des tests comme ça tout le temps.
- Dépend. Il y a une différence entre la liste de tous les très bons vins de l'Irlande (qui est une liste vide) et tous les très bons vins dans le monde de Narnia (qui est nulle, parce que le monde de Narnia n'existe pas). Parfois, il est nécessaire de distinguer la valeur null de vide. Je suis d'accord que l'on doit se pencher vers le retour à vide cependant.
- Utiliser la valeur null pour signaler une condition spéciale est comme une automobile en appliquant le frein à main pour indiquer qu'il est faible sur le gaz.
- Utiliser la valeur null pour indiquer une condition nulle, c'est comme, euh, quelque chose de vraiment évidente et directe et sensible.
- Ces jours-ci, l'objet null modèle est assez souvent considérés comme dangereux ou de mauvaise pratique - pour une bonne raison. À utiliser avec précaution.
- Hanna, je suis d'accord que null est un bon indicateur de non-validité de énumérable état, même si, en général, vous auriez probablement souhaitez lancer une exception plutôt que d'indiquer état non valide. Cela dit, il semble mal à me traiter null énumérable comme si il était vide; je serais probablement créer des méthodes de l'adaptateur autour de la délinquance de la classe que compenser le déficit de sorte que le code du client est isolé à partir d'elle. C'est plus de code à écrire un adaptateur séparé pour chaque imparfait méthode, mais il permet au client de code plus propre.
- Je suis en désaccord, je ne pense pas que null est un bon indicateur d'un état non valide. C'est un bon indicateur quand "énumérable n'existe pas" et "énumérable existe et est vide" sont à la fois valables et peut-être à dessein distingués. Quand ils sont tous les deux valides, mais aucune différence, puis un vide énumérables dans le null-objet modèle de roches (un de mes préférés), et quand on n'est pas valide, je jetterais une exception. Tous les trois cas peuvent se produire dans le raisonnable bien pensé code.
- Merci les gars pour tous les commentaires. C'est de l'inspiration pour un article de blog, et un crédit sera accordé.
InformationsquelleAutor Anon.
14

Comment sur
```
count = myEnumerable == null? 0 : myEnumerable.Count()
```
- J'ai le sentiment que hes va demander un plus propre que ça, +1 n'en est pas moins 🙂
- Votre sentiment est correct, mais c'est une bonne réponse de toute façon.
InformationsquelleAutor cordialgerm
9

Je ne pense pas que l'aide de la méthode d'extension est une mauvaise idée.
```
public static int NullableCount<T>(this IEnumerable<T> collection)
{
   return collection == null ? 0 : collection.Count();
}
```
- +1 j'ai fait exactement la même chose - juste nommé CountOrZero. Personnellement, je pense que c'est plus clair.
InformationsquelleAutor Cheng Chen
5

- Je utiliser une méthode d'extension personnalisée:
```
public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
{
    return source ?? Enumerable.Empty<T>();
}

...

int count = myEnumerable.EmptyIfNull().Count();
```
- +1, je pense que c'est le plus propre de la méthode d'extension solutions énumérées. Il est très explicite sur le fait que vous êtes en supposant une valeur null énumérable à être tout simplement vide, après quoi vous pouvez travailler avec le énumérable comme d'habitude.
InformationsquelleAutor Thomas Levesque
2

Je voudrais aussi écrire ma propre méthode d'extension CountOrZeroForNull, comme dans d'autres réponses.

D'ailleurs... au Lieu de:
```
var count = (myEnumerable ?? new string[0]).Count();
                          //^^^^^^^^^^^^^
```
vous pourriez écrire:
```
var count = (myEnumerable ?? Enumerable.Empty<string>()).Count();
                          //^^^^^^^^^^^^^^^^^^^^^^^^^^
```
Ce n'est pas de soulager votre problème spécifique, mais il contourne l'allocation d'une partie inutilisée de tableau. (Enumerable.Empty<T> est probablement mis en œuvre comme une simple yield break déclaration.)
- L'implémentation actuelle de Enumerable.Empty<T> retourne en fait un singleton vide T[] tableau.
- @LukeH: je n'aurais pas pensé ça. Merci pour regarder ceci.
InformationsquelleAutor stakx
2

Tout simplement créer votre propre méthode d'extension qui gère null enumerables comme vous le souhaitez.
```
public int CountOrNull<T>(this IEnumerable<T> source)
{
    return source == null ? 0 : source.Count();
}
```
Vous pouvez simplement utiliser:
```
var list1 = new int[] { 1, 2, 3, 4 };
var list2 = (int[])null;

var count1 = list1.CountOrNull(); //4
var count2 = list2.CountOrNull(); //0
```
C'est la grande chose au sujet des méthodes d'extension. Ils fonctionnent toujours bien, même si l'objet sur lequel (vous semblez être) en appelant la méthode est null.
- @Noldorin: correction d'une coquille dans votre exemple de code (le // 4 commentaire); peut-être vérifier que c'est bien ce que vous souhaitiez.
- Merci; c'était en effet une faute de frappe.
InformationsquelleAutor Noldorin
2

En 2019, le tidiest façon de le faire est var count = myEnumerable?.Count() ?? 0;.

InformationsquelleAutor Licht

Quelles sont les actions que vous prenez si la valeur retournée est 0?

Si c'est ce qui est intéressant, peut-être que vous devriez utiliser Haack est IsNullOrEmpty méthode d'extension pour IEnumerable comme suit:

public static bool IsNullOrEmpty<T>(this IEnumerable<T> items) 
{
    return items == null || !items.Any();
}

Le lien est http://haacked.com/archive/2010/06/10/checking-for-empty-enumerations.aspx

Posté un commentaire sur le blog, vous trouverez également un Exception classe, j'ai écrit pour aller avec ça:

public class ArgumentNullOrEmptyException : ArgumentNullException
{
    public ArgumentNullOrEmptyException( string paramName ) : base( paramName )
    {}

    public ArgumentNullOrEmptyException( string paramName, string message ) : base( paramName, message )
    {}

    public override string Message
    {
        get
        {
            return "Value cannot be null nor empty.{0}Parameter name: {1}".FormatWith( Environment.NewLine, ParamName );
        }
    }
}

InformationsquelleAutor Martin R-L

-2
```
var count = 0; 

if (myEnumerable != null) 
    count = myEnumerable.Count(); 
```
Alors que ce n'est pas aussi technique que les autres réponses, il est de loin le plus lisible.
- Je ne pense pas que ces trois lignes sont plus lisible qu'un bien-nommée méthode d'extension.
- Oui, je veux éviter de répéter la même vérifier plusieurs fois. C'était le point de ma question, après tout.
- Heh, peut-être lu la question?
InformationsquelleAutor NibblyPig

Vous devez vous connecter pour publier un commentaire.