É if (items! = Null) supérfluo antes de foreach (T item nos itens)?

Costumo encontrar códigos como o seguinte:

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

Basicamente, a ifcondição garante que o foreachbloco será executado apenas se itemsnão for nulo. Estou me perguntando se a ifcondição é realmente necessária ou foreachse tratarei do caso items == null.

Quer dizer, posso simplesmente escrever

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

sem se preocupar se itemsé nulo ou não? A ifcondição é supérflua? Ou isso depende do tipo de itemsou talvez em Tbem?

Você ainda precisa verificar se (items! = Null), caso contrário, você obterá NullReferenceException. No entanto, você pode fazer algo assim:

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

mas você pode verificar o desempenho dele. Portanto, ainda prefiro ter if (items! = Null) primeiro.

Com base na sugestão de Eric Lippert, mudei o código para:

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

Usando C # 6, você pode usar o novo operador condicional nulo junto com List<T>.ForEach(Action<T>) (ou seu próprioIEnumerable<T>.ForEach método de extensão).

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

A verdadeira lição aqui deve ser uma sequência quase nunca deve ser nula em primeiro lugar . Basta torná-lo uma invariante em todos os seus programas para que, se você tiver uma sequência, ela nunca seja nula. É sempre inicializado para ser a sequência vazia ou alguma outra sequência genuína.

Se uma sequência nunca for nula, obviamente você não precisa verificá-la.

Na verdade, há uma solicitação de recurso nesse @Connect: http://connect.microsoft.com/VisualStudio/feedback/details/93497/foreach-should-check-for-null

E a resposta é bastante lógica:

Acho que a maioria dos loops foreach são escritos com a intenção de iterar uma coleção não nula. Se você tentar iterar por meio de null, deverá obter sua exceção, para que possa corrigir seu código.

Você sempre pode testar com uma lista nula ... mas isso é o que eu encontrei no site do msdn

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

Se expression tiver o valor null, um System.NullReferenceException será lançado.

Não é supérfluo. No tempo de execução, os itens serão lançados em um IEnumerable e seu método GetEnumerator será chamado. Isso causará uma desreferenciação de itens que falharão

Você pode encapsular a verificação nula em um método de extensão e usar um 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);
      }
    }
  }
}

O código se torna:

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

Pode ser ainda mais conciso se você quiser apenas chamar um método que pega um item e retorna void:

items.ForEach(MethodThatTakesAnItem);

Você precisa disso. Você obterá uma exceção ao foreachacessar o contêiner para configurar a iteração de outra forma.

Nos bastidores, foreachusa uma interface implementada na classe de coleção para realizar a iteração. A interface genérica equivalente está aqui .

A instrução foreach da linguagem C # (para cada um no Visual Basic) esconde a complexidade dos enumeradores. Portanto, usar foreach é recomendado em vez de manipular diretamente o enumerador.

O teste é necessário, porque se a coleção for nula, foreach lançará uma NullReferenceException. Na verdade, é muito simples de experimentar.

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

o segundo vai lançar um NullReferenceExceptioncom a mensagemObject reference not set to an instance of an object.

Conforme mencionado aqui, você precisa verificar se não é nulo.

Não use uma expressão avaliada como nula.

Em C # 6, você pode escrever sth assim:

// 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)
{
    //..
}

É basicamente a solução de Vlad Bezden, mas usando o ?? expressão para sempre gerar uma matriz que não seja nula e, portanto, sobreviva a foreach, em vez de ter essa verificação dentro do colchete foreach.