Come faccio a dire a Resharper che il mio metodo IEnumerable rimuove i null?

Question

Dato il seguente codice, ReSharper sarà correttamente mi avvisate su una possibile NullReferenceException su foo.Bar perché ci potrebbero essere elementi nulli nella enumerabile:

IEnumerable<Foo> foos = GetFoos(); 
var bars = foos.Select(foo => foo.Bar); 

Un modo per soddisfare l'analizzatore statico è quello di escludere esplicitamente i valori nulli:

IEnumerable<Foo> foos = GetFoos().Where(foo => foo != null); 

mi ritrovo a digitare .Where(x => x != null) molto, quindi ho avvolto in su in un metodo di estensione, e ora posso effettuare le seguenti operazioni:

IEnumerable<Foo> foos = GetFoos().NotNull(); 

Il problema è che Resharper non sa che NotNull() elimina i valori nulli. C'è un modo in cui posso insegnare Resharper su questo fatto? In generale, c'è un modo per dire a Resharper che un metodo IEnumerable -returning non avrà mai nulla in esso (in modo che io possa annotare direttamente GetFoos())?

So che posso usare per dire the NotNullAttribute ReSharper che la stessa enumerabile non è nullo, ma non riesco a trovare uno che parla delle contenuti del enumerabile.

Edit: Il metodo di estensione appare esattamente come ci si aspetterebbe:

[NotNull] 
public static IEnumerable<T> NotNull<T>(this IEnumerable<T> enumerable) 
{ 
    return enumerable.Where(x => x != null); 
} 

Answer 1

È possibile utilizzare ItemNotNullAttribute che indica a ReSharper che nessun elemento di una raccolta può mai essere null.

Answer 2

Un modo come avete dichiarato è quello di utilizzare [NotNull] attributo che istruiscono il motore ReSharper per arrestare il controllo di errore di riferimento null per quella particolare variabile.

Oppure, se non si vuole utilizzare tale attributo è possibile opzionalmente utilizzare i commenti

// ReSharper disable PossibleNullReferenceException 
     var bars = foos.Select(foo => foo.Bar); 
// ReSharper restore PossibleNullReferenceException 

Per fare un punto a questa domanda, ReSharper non può attraversare attraverso runtime i valori di calcolo di istruzione in modo che possa fare un giudizio che non può essere nullo.