Ответ 1

Попробуйте следующий код:

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

Поздний EDIT, потому что для этих проверок теперь я хотел бы использовать следующее решение. Сначала добавьте метод многократного повторного использования под названием 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;
        }
    }
}

И тогда вы можете сделать то же самое, что:

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

Я лично считаю это менее подробным и более легким для чтения. Теперь вы можете безопасно обращаться к любой коллекции без необходимости нулевой проверки.

Ответ 2

Для тех, у кого нет гарантии, что список не будет пустым, вы можете использовать оператор с нулевым условием, чтобы безопасно проверять пустые и пустые списки в одном условном выражении:

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

Ответ 3

Оформить заказ L-Four.

Менее эффективный ответ:

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

В основном new List<T> не будет null но не будет содержать никаких элементов. Как отмечено в комментариях, вышесказанное выдает исключение, если список не является обязательным. Но что касается фрагмента в вопросе, где он создается, то выше будет работать нормально.

Если вам нужно проверить значение null, это будет:

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

Еще лучше использовать !myList.Any() и, как упоминается в вышеупомянутом ответе L-Four, поскольку короткое замыкание быстрее, чем линейный подсчет элементов в списке.

Ответ 4

Как насчет использования метода расширения?

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

Ответ 5

Предполагая, что список никогда не является нулевым, следующий код проверяет, пуст ли пуст и добавляет новый элемент, если он пуст:

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

Если возможно, что список равен null, перед условием Any() необходимо добавить нулевую проверку:

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

По-моему, предпочтительнее использовать Any() вместо Count == 0 поскольку он лучше выражает намерение проверить, имеет ли список какой-либо элемент или пуст. Однако, учитывая эффективность каждого подхода, использование Any() обычно медленнее, чем Count.

Ответ 6

В вашем списке нет элементов, поэтому для доступа к несуществующему 0-му элементу

myList[0] == null

throws Index был исключен за пределы исключения; когда вы хотите получить доступ к проверке n-го элемента

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

в твоем случае

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

Ответ 7

Если вам требуется однострочное условие, которое проверяет как пустые, так и пустые, вы можете использовать

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

Это будет работать в старых версиях версий, где оператор с нулевым условием недоступен.

Ответ 8

Мне было интересно, что никто не предложил создать собственный метод расширения, более понятное имя для OP case.

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

    return source.Any() == false;
}

Ответ 9

List в c# имеет свойство Count. Его можно использовать так:

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

Ответ 10

myList[0] получает первый элемент в списке. Поскольку список пуст, нет элемента для получения, и вместо этого вы получаете IndexOutOfRangeException.

Как показали другие ответы, чтобы проверить, пуст ли список, вам нужно получить количество элементов в списке (myList.Count) или использовать метод LINQ. .Any() который вернет true, если есть какие-либо элементы в списке.

Ответ 11

Попробуйте и используйте:

if(myList.Any())
{

}

Примечание: это не означает, что myList не является нулевым.

Ответ 12

if (myList?.Any() == true) 
{
   ...
}

Я считаю это самым удобным способом. '== true' проверяет значение nullable bool, подразумеваемого '..Any()

Ответ 13

Мы можем проверить, как показано ниже, с помощью методов расширения. Я использую их для всех своих проектов.

  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 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 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;
}

Ответ 14

Вы можете использовать свойство Count для List в С#

ниже приведен код, который проверяет список пустым и нулевым как в одном условии

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

Ответ 15

Поскольку вы инициализируете myList с помощью "new", сам список никогда не будет нулевым.

Но он может быть заполнен нулевыми значениями.

В этом случае .Count > 0 и .Any() будут истинными. Вы можете проверить это с помощью .All(s => s == null)

var myList = new List<object>();
if (myList.Any() || myList.All(s => s == null))

Ответ 16

Мы можем добавить расширение для создания пустого списка

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

И пользуйся вот так

foreach (model in models.Nullable())
{
    ....
}

Ответ 17

Простой способ объединить myList == null || myList.Count == 0 - использовать оператор объединения нулей ??:

if ((myList?.Count ?? 0) == 0) {
    //My list is null or empty
}