Czy jeśli (items! = Null) jest zbędne przed foreach (pozycja T w pozycjach)?

Często napotykam kod podobny do następującego:

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

Zasadniczo ifwarunek zapewnia, że foreachblok zostanie wykonany tylko wtedy, gdy itemsnie jest pusty. Zastanawiam się, czy ifstan jest naprawdę potrzebny, czy poradzę foreachsobie w przypadku items == null.

To znaczy, mogę po prostu napisać

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

bez martwienia się o itemsto, czy jest zerowy, czy nie? Czy ifstan jest zbędny? Czy to zależy od typu z itemslub może on Ttakże?

Nadal musisz sprawdzić, czy (items! = Null), w przeciwnym razie otrzymasz NullReferenceException. Możesz jednak zrobić coś takiego:

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

ale możesz sprawdzić jego wydajność. Więc nadal wolę mieć najpierw if (items! = Null).

Na podstawie sugestii Erica Lipperta zmieniłem kod na:

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

Używając C # 6, możesz użyć nowego operatora warunkowego o wartości null razem z List<T>.ForEach(Action<T>)(lub własną IEnumerable<T>.ForEachmetodą rozszerzającą).

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

Prawdziwym rozwiązaniem na wynos powinien być ciąg, który prawie nigdy nie powinien być zerowy . Po prostu uczyń niezmiennym we wszystkich swoich programach, że jeśli masz sekwencję, nigdy nie jest zerowa. Jest zawsze inicjowana jako pusta sekwencja lub inna oryginalna sekwencja.

Jeśli sekwencja nigdy nie jest zerowa, to oczywiście nie musisz jej sprawdzać.

Właściwie na tym @Connect jest żądanie funkcji: http://connect.microsoft.com/VisualStudio/feedback/details/93497/foreach-should-check-for-null

Odpowiedź jest całkiem logiczna:

Myślę, że większość pętli foreach jest napisanych z zamiarem iteracji kolekcji niezerowej. Jeśli spróbujesz iterować przez null, powinieneś otrzymać wyjątek, abyś mógł naprawić swój kod.

Zawsze możesz to przetestować z pustą listą ... ale to właśnie znalazłem na stronie internetowej msdn

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

Jeśli wyrażenie ma wartość null, zostanie zgłoszony System.NullReferenceException.

Nie jest to zbyteczne. W czasie wykonywania elementy zostaną rzutowane na IEnumerable i zostanie wywołana metoda GetEnumerator. Spowoduje to wyłuskanie elementów, które się nie powiodą

Możesz hermetyzować sprawdzanie wartości null w metodzie rozszerzenia i użyć wyrażenia 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);
      }
    }
  }
}

Kod staje się:

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

Jeśli może być jeszcze bardziej zwięzłe, jeśli chcesz po prostu wywołać metodę, która pobiera element i zwraca void:

items.ForEach(MethodThatTakesAnItem);

Potrzebujesz tego. Otrzymasz wyjątek, kiedyforeach dostęp do kontenera, aby skonfigurować iterację w inny sposób.

Pod okładkami foreachużywa interfejsu zaimplementowanego w klasie kolekcji do wykonania iteracji. Ogólny odpowiednik interfejsu jest tutaj .

Instrukcja foreach języka C # (dla każdego w Visual Basic) ukrywa złożoność modułów wyliczających. Dlatego zaleca się używanie foreach zamiast bezpośredniego manipulowania modułem wyliczającym.

Test jest konieczny, ponieważ jeśli kolekcja ma wartość null, foreach zgłosi NullReferenceException. Właściwie to całkiem proste, aby to wypróbować.

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

druga wyśle NullReferenceExceptionz wiadomościąObject reference not set to an instance of an object.

Jak wspomniano tutaj , musisz sprawdzić, czy nie jest to wartość zerowa.

Nie używaj wyrażenia, którego wynikiem jest null.

W C # 6 możesz napisać coś tak:

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

Jest to w zasadzie rozwiązanie Vlada Bezdena, ale przy użyciu ?? expression, aby zawsze generować tablicę, która nie jest null i dlatego przetrwa foreach zamiast sprawdzania wewnątrz nawiasu foreach.