¿Es if (items! = Null) superfluo antes de foreach (item T in items)?

A menudo me encuentro con un código como el siguiente:

if ( items != null)
{
   foreach(T item in items)
   {
        //...
   }
}

Básicamente, la ifcondición asegura que el foreachbloque se ejecutará solo si itemsno es nulo. Me pregunto si la ifcondición es realmente necesaria, o foreachmanejaré el caso si items == null.

Quiero decir, puedo simplemente escribir

foreach(T item in items)
{
    //...
}

sin preocuparse de si itemses nulo o no? ¿La ifcondición es superflua? ¿O esto depende del tipo de itemso quizás Ttambién?

Aún debe verificar si (items! = Null); de lo contrario, obtendrá NullReferenceException. Sin embargo, puede hacer algo como esto:

List<string> items = null;  
foreach (var item in items ?? new List<string>())
{
    item.Dump();
}

pero puede comprobar su rendimiento. Así que todavía prefiero tener if (items! = Null) primero.

Según la sugerencia de Lippert de Eric, cambié el código a:

List<string> items = null;  
foreach (var item in items ?? Enumerable.Empty<string>())
{
    item.Dump();
}

Usando C # 6, podría usar el nuevo operador condicional nulo junto con List<T>.ForEach(Action<T>)(o su propio IEnumerable<T>.ForEachmétodo de extensión).

List<string> items = null;
items?.ForEach(item =>
{
    // ...
});

La conclusión real aquí debería ser una secuencia que casi nunca debería ser nula en primer lugar . Simplemente conviértalo en un invariante en todos sus programas que si tiene una secuencia, nunca es nulo. Siempre se inicializa para que sea la secuencia vacía o alguna otra secuencia genuina.

Si una secuencia nunca es nula, obviamente no es necesario verificarla.

En realidad, hay una solicitud de función en ese @Connect: http://connect.microsoft.com/VisualStudio/feedback/details/93497/foreach-should-check-for-null

Y la respuesta es bastante lógica:

Creo que la mayoría de los bucles foreach se escriben con la intención de iterar una colección no nula. Si intenta iterar a través de null, debería obtener su excepción, para que pueda corregir su código.

Siempre puede probarlo con una lista nula ... pero esto es lo que encontré en el sitio web de msdn

foreach-statement:
    foreach   (   type   identifier   in   expression   )   embedded-statement 

Si la expresión tiene el valor nulo, se lanza una excepción System.NullReferenceException.

No es superfluo. En tiempo de ejecución, los elementos se convertirán en un IEnumerable y se llamará a su método GetEnumerator. Eso provocará una desreferenciación de elementos que fallarán

Puede encapsular la verificación nula en un método de extensión y usar una lambda:

public static class EnumerableExtensions {
  public static void ForEach<T>(this IEnumerable<T> self, Action<T> action) {
    if (self != null) {
      foreach (var element in self) {
        action(element);
      }
    }
  }
}

El código se convierte en:

items.ForEach(item => { 
  ...
});

Si puede ser aún más conciso si solo desea llamar a un método que toma un elemento y devuelve void:

items.ForEach(MethodThatTakesAnItem);

Necesitas esto. Obtendrá una excepción cuando foreachacceda al contenedor para configurar la iteración de lo contrario.

Debajo de las cubiertas, foreachutiliza una interfaz implementada en la clase de colección para realizar la iteración. La interfaz equivalente genérica está aquí .

La instrucción foreach del lenguaje C # (para cada uno en Visual Basic) oculta la complejidad de los enumeradores. Por lo tanto, se recomienda utilizar foreach en lugar de manipular directamente el enumerador.

La prueba es necesaria, porque si la colección es nula, foreach lanzará una NullReferenceException. De hecho, es bastante sencillo probarlo.

List<string> items = null;
foreach(var item in items)
{
   Console.WriteLine(item);
}

el segundo lanzará un NullReferenceExceptioncon el mensajeObject reference not set to an instance of an object.

Como se mencionó aquí , debe verificar si no es nulo.

No utilice una expresión que se evalúe como nula.

En C # 6 puedes escribir algo como esto:

// some string from file or UI, i.e.:
// a) string s = "Hello, World!";
// b) string s = "";
// ...
var items = s?.Split(new char[] { ',', '!', ' ' }) ?? Enumerable.Empty<string>();  
foreach (var item in items)
{
    //..
}

Es básicamente la solución de Vlad Bezden, pero usando el ?? expresión para generar siempre una matriz que no sea nula y, por lo tanto, sobreviva al foreach en lugar de tener esta comprobación dentro del corchete foreach.