Utilizzare in modo esplicito il metodo di estensione

Question

Sto avendo un List<T> e voglio ottenere i valori indietro nell'ordine inverso. Quello che non voglio è invertire la lista stessa.

Questo sembra non avere alcun problema poiché c'è un metodo di estensione Reverse() per IEnumerable<T> che fa esattamente quello che voglio.

Il mio problema è che esiste anche un metodo Reverse() per List<T> che inverte l'elenco stesso e restituisce void.

So che ci sono un sacco di modi per attraversare l'elenco in ordine inverso, ma la mia domanda è:

Come faccio a dire al compilatore che voglio utilizzare il metodo di estensione con lo stesso nome?

var list = new List<int>(new [] {1, 2, 3}); 
DumpList(list.Reverse());     // error 

Answer 1

Il modo migliore per legarsi esplicitamente ad un particolare metodo di estensione è di chiamare utilizzando la sintassi metodo condiviso. Nel tuo caso, hai fatto come:

DumpList(Enumerable.Reverse(list)); 

Il problema con alcuni degli altri approcci di cui qui è che non sempre fare quello che vuoi. Ad esempio, la fusione della lista in questo modo:

((IEnumerable)list).Reverse() 

potrebbe finire per chiamare un metodo completamente diverso a seconda gli spazi dei nomi che hai importato, o che tipo il codice chiamante è definito in

L'unico modo per. essere sicuro al 100% di associare a un particolare metodo di estensione è utilizzare la sintassi del metodo condiviso.

Answer 2

var list = new List<int>(new [] {1, 2, 3}); 
DumpList((list as IEnumerable<int>).Reverse()); 

O

IEnumerable<int> list = new List<int>(new [] {1, 2, 3}); 
DumpList(list.Reverse()); 

Answer 3

Se non ti dispiace la bruttezza, e lei ha scritto il metodo di estensione, si può sempre chiamare:

MyExtensions.Reverse(list); 

E 'ancora solo un metodo statico nel cuore. L'ho capito ieri quando ReSharper è impazzito e ha deciso di riscrivere metà dei miei metodi di estensione come chiamate al metodo statico.

Per quanto riguarda l'utilizzo dell'IEnumerable <T> rispetto a Elenco <T>, non sembra così semplice. Il mio primo pensiero sarebbe quello di utilizzare:

IEnumerable<T>.Reverse<T>(list); 

Ma che mi sta dando un errore di compilazione, e la risposta di Giovanni è corretto per IEnumerable/List.

Answer 4

Non è necessario eseguire il cast del parametro per ottenere il metodo giusto selezionato ... è sufficiente essere più specifici sul metodo.

List<int> list = new List<int>() {1, 2, 3}; 
DumpList(Enumerable.Reverse(list)); 

Answer 5

Questo sembra funzionare

var stuff = new List<int>(); 
    var list = Enumerable.Reverse(stuff);