web-dev-qa-db-fra.com

Vérification de la liste vide ou nulle <chaîne>

J'ai une liste où parfois il est vide ou nul. Je veux pouvoir vérifier s'il contient un élément de la liste et sinon ajouter un objet à la liste.

 // I have a list, sometimes it doesn't have any data added to it
    var myList = new List<object>(); 
 // Expression is always false
    if (myList == null) 
        Console.WriteLine("List is never null"); 
    if (myList[0] == null) 
        myList.Add("new item"); 
    //Errors encountered:  Index was out of range. Must be non-negative and less than the size of the collection.
    // Inner Exception says "null"
c#list
33
Jonathan Kittell

Essayez le code suivant:

 if ( (myList!= null) && (!myList.Any()) )
 {
     // Add new item
     myList.Add("new item"); 
 }

Un EDIT tardif car pour ces vérifications, j’aimerais maintenant utiliser la solution suivante ..__ Tout d’abord, ajoutez une petite méthode d’extension réutilisable appelée Safe ():

public static class IEnumerableExtension
{       
    public static IEnumerable<T> Safe<T>(this IEnumerable<T> source)
    {
        if (source == null)
        {
            yield break;
        }

        foreach (var item in source)
        {
            yield return item;
        }
    }
}

Et ensuite, vous pouvez faire la même chose comme:

 if (!myList.Safe().Any())
 {
      // Add new item
      myList.Add("new item"); 
 }

Personnellement, je trouve cela moins verbeux et plus facile à lire. Vous pouvez maintenant accéder en toute sécurité à n'importe quelle collection sans avoir besoin d'un contrôle nul.

46
L-Four

Pour les personnes qui n'ont pas la garantie que la liste not ne sera pas nulle, vous pouvez utiliser l'opérateur null-conditionnel pour vérifier en toute sécurité les listes nulles et vides dans une seule instruction conditionnelle:

if (list?.Any() != true)
{
    // Handle null or empty list
}
31
mech

Checkout L-Four's réponse.

Une réponse moins efficace:

if(myList.Count == 0){
    // nothing is there. Add here
}

Fondamentalement, new List<T> ne sera pas null mais n'aura aucun élément. Comme indiqué dans les commentaires, ce qui précède lève une exception si la liste n'est pas instanciée. Mais en ce qui concerne l'extrait de code dans la question, où il est instancié, ce qui précède fonctionnera parfaitement.

Si vous devez vérifier null, alors ce serait:

if(myList != null && myList.Count == 0){
  // The list is empty. Add something here
}

Encore mieux serait d'utiliser !myList.Any() et, comme mentionné dans la réponse de L-Four susmentionnée, le court-circuitage est plus rapide que le comptage linéaire des éléments de la liste.

19
Amit Joki

Qu'en est-il de l'utilisation d'une méthode d'extension?

public static bool AnyOrNotNull<T>(this IEnumerable<T> source)
{
  if (source != null && source.Any())
    return true;
  else
    return false;
}
12
swissben

En supposant que la liste n'est jamais nulle, le code suivant vérifie si la liste est vide et ajoute un nouvel élément s'il est vide:

if (!myList.Any())
{
    myList.Add("new item");
}

S'il est possible que la liste soit nulle, une vérification NULL doit être ajoutée avant la condition Any():

if (myList != null && !myList.Any())
{
    myList.Add("new item");
}

À mon avis, utiliser Any() au lieu de Count == 0 est préférable car il exprime mieux l'intention de vérifier si la liste contient un élément ou si elle est vide . Cependant, compte tenu des performances de chaque approche, l'utilisation de Any() est généralement lent que Count.

6
Luca Cremonesi

Votre liste n'a pas d'article , c'est pourquoi l'accès à n'existe pas 0ème article 

myList[0] == null

jette Index était hors limite exception ; quand vous voulez accéder à n-ème vérification de poste

  if (myList.Count > n)
    DoSomething(myList[n])

dans ton cas

  if (myList.Count > 0) // <- You can safely get 0-th item
    if (myList[0] == null) 
      myList.Add("new item");
3
Dmitry Bychenko

Si vous souhaitez une condition de ligne unique vérifiant à la fois les valeurs null et vide, vous pouvez utiliser

if (list == null ? true : (!list.Any()))

Cela fonctionnera dans les versions précédentes de la structure où l'opérateur null-conditionnel n'est pas disponible.

3
johnnydanger

List dans c# a une propriété Count. Il peut être utilisé comme suit:

if(myList == null) // Checks if list is null
    // Wasn't initialized
else if(myList.Count == 0) // Checks if the list is empty
    myList.Add("new item");
else // List is valid and has something in it
    // You could access the element in the list if you wanted
2
Andrew_CS

myList[0] obtient le premier élément de la liste. Comme la liste est vide, il n’ya pas d’objet à obtenir et vous obtenez plutôt IndexOutOfRangeException.

Comme l’ont montré d’autres réponses, afin de vérifier si la liste est vide, vous devez obtenir le nombre d’éléments dans la liste (myList.Count) ou utiliser la méthode LINQ .Any(), qui renvoie true si la liste contient des éléments.

2
Andrew Cooper

Je me demandais si personne ne suggérait de créer un nom plus lisible pour la méthode d’extension propre à OP.

public static bool IsNullOrEmpty<T>(this IEnumerable<T> source)
{
    if (source == null)
    {
        return true;
    }

    return source.Any() == false;
}
1
Basin

Essayez et utilisez: 

if(myList.Any())
{

}

Remarque: cela suppose que ma liste n'est pas nulle.

1
Alexandru Chichinete

Parce que vous initialisez myList avec 'new', la liste elle-même ne sera jamais nulle.

Mais il peut être rempli avec des valeurs 'nulles'. 

Dans ce cas, .Count > 0 et .Any() seront vrais. Vous pouvez vérifier cela avec la .All(s => s == null)

var myList = new List<object>();
if (myList.Any() || myList.All(s => s == null))
0
Tessa
if (myList?.Any() == true) 
{
   ...
}

Je trouve cela le moyen le plus pratique. '== true' vérifie la valeur du booléen nullable impliqué par '? .Any ()

0
bvh9000

Nous pouvons valider comme ci-dessous avec les méthodes d'extension. Je les utilise pour tous mes projets.

  var myList = new List<string>();
  if(!myList.HasValue())
  {
     Console.WriteLine("List has value(s)");              
  }

  if(!myList.HasValue())
  {
     Console.WriteLine("List is either null or empty");           
  }

  if(myList.HasValue())
  {
      if (!myList[0].HasValue()) 
      {
          myList.Add("new item"); 
      }
  }




/// <summary>
/// This Method will return True if List is Not Null and it's items count>0       
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="items"></param>
/// <returns>Bool</returns>
public static bool HasValue<T>(this IEnumerable<T> items)
{
    if (items != null)
    {
        if (items.Count() > 0)
        {
            return true;
        }
    }
    return false;
}


/// <summary>
/// This Method will return True if List is Not Null and it's items count>0       
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="items"></param>
/// <returns></returns>
public static bool HasValue<T>(this List<T> items)
{
    if (items != null)
    {
        if (items.Count() > 0)
        {
            return true;
        }
    }
    return false;
}


/// <summary>
///  This method returns true if string not null and not empty  
/// </summary>
/// <param name="ObjectValue"></param>
/// <returns>bool</returns>
public static bool HasValue(this string ObjectValue)
{
    if (ObjectValue != null)
    {
        if ((!string.IsNullOrEmpty(ObjectValue)) && (!string.IsNullOrWhiteSpace(ObjectValue)))
        {
            return true;
        }
    }
    return false;
}
0
Anandha

Vous pouvez utiliser la propriété Count de List en c #

s'il vous plaît trouver ci-dessous le code qui liste de contrôle vide et null à la fois dans une seule condition 

if(myList == null || myList.Count == 0)
{
    //Do Something 
}
0
Niraj Trivedi

Nous pouvons ajouter une extension pour créer une liste vide 

    public static IEnumerable<T> Nullable<T>(this IEnumerable<T> obj)
    {
        if (obj == null)
            return new List<T>();
        else
            return obj;
    }

Et utiliser comme ça

foreach (model in models.Nullable())
{
    ....
}
0
Damian Haynes