Quando utilizzare IList e quando utilizzare Elenco

So che IList è l'interfaccia e List è il tipo concreto, ma non so ancora quando usarli. Quello che sto facendo ora è se non ho bisogno dei metodi Sort o FindAll che utilizzo l'interfaccia. Ho ragione? Esiste un modo migliore per decidere quando utilizzare l'interfaccia o il tipo concreto?

Seguo due regole:

• Accetta il tipo più semplice che funzionerà
• Restituisce il tipo più ricco di cui l'utente avrà bisogno

Pertanto, quando si scrive una funzione o un metodo che accetta una raccolta, scriverla non per prendere un elenco, ma un IList <T>, un ICollection <T> o IEnumerable <T>. Le interfacce generiche continueranno a funzionare anche per elenchi eterogenei perché System.Object può essere anche una T. In questo modo risparmierai mal di testa se decidi di utilizzare uno Stack o qualche altra struttura di dati più avanti. Se tutto ciò che devi fare nella funzione è foreach attraverso di essa, IEnumerable <T> è davvero tutto ciò che dovresti chiedere.

D'altra parte, quando si restituisce un oggetto da una funzione, si desidera offrire all'utente il set più completo possibile di operazioni senza che debbano eseguire il cast. Quindi, in tal caso, se si tratta di un Elenco <T> internamente, restituire una copia come Elenco <T>.

Le linee guida Microsoft controllate da FxCop scoraggiano l'uso dell'elenco <T> nelle API pubbliche - preferisci IList <T>.

Per inciso, ora quasi sempre dichiaro matrici monodimensionali come IList <T>, il che significa che posso usare costantemente la proprietà IList <T> .Count anziché Array.Length. Per esempio:

public interface IMyApi
{
    IList<int> GetReadOnlyValues();
}

public class MyApiImplementation : IMyApi
{
    public IList<int> GetReadOnlyValues()
    {
        List<int> myList = new List<int>();
        ... populate list
        return myList.AsReadOnly();
    }
}
public class MyMockApiImplementationForUnitTests : IMyApi
{
    public IList<int> GetReadOnlyValues()
    {
        IList<int> testValues = new int[] { 1, 2, 3 };
        return testValues;
    }
}

C'è una cosa importante che le persone sembrano sempre trascurare:

È possibile passare un array semplice a qualcosa che accetta un IList<T>parametro, quindi è possibile chiamare IList.Add()e ricevere un'eccezione di runtime:

Unhandled Exception: System.NotSupportedException: Collection was of a fixed size.

Ad esempio, considera il seguente codice:

private void test(IList<int> list)
{
    list.Add(1);
}

Se lo chiami come segue, otterrai un'eccezione di runtime:

int[] array = new int[0];
test(array);

Ciò accade perché l'utilizzo di matrici semplici con IList<T>violazione del principio di sostituzione di Liskov.

Per questo motivo, se stai chiamando IList<T>.Add()potresti prendere in considerazione l'idea di richiedere un List<T>invece di un IList<T>.

Concordo con il consiglio di Lee per prendere parametri, ma non tornare.

Se specifichi i tuoi metodi per restituire un'interfaccia, ciò significa che sei libero di modificare l'esatta implementazione in un secondo momento senza che il metodo di consumo lo sappia mai. Ho pensato che non avrei mai dovuto cambiare da un Elenco <T>, ma in seguito ho dovuto cambiare per utilizzare una libreria di elenchi personalizzati per le funzionalità extra fornite. Perché avevo restituito solo un IList <T> nessuna delle persone che utilizzavano la libreria doveva cambiare il proprio codice.

Ovviamente ciò deve applicarsi solo ai metodi che sono visibili esternamente (cioè metodi pubblici). Personalmente utilizzo le interfacce anche nel codice interno, ma poiché sei in grado di modificare tutto il codice da solo se apporti modifiche non è strettamente necessario.

IEnumerable
Dovresti provare ad usare il tipo meno specifico adatto al tuo scopo.
IEnumerableè meno specifico di IList.
Si utilizza IEnumerablequando si desidera scorrere gli elementi in una raccolta.

Ilist
IList implementa IEnumerable.
Dovresti usare IListquando hai bisogno di accedere per indice alla tua collezione, aggiungere ed eliminare elementi, ecc ...

Elenco
List strumenti IList.

È sempre meglio utilizzare il tipo di base più basso possibile. Ciò offre all'implementatore della tua interfaccia, o utente del tuo metodo, l'opportunità di utilizzare ciò che preferisce dietro le quinte.

Per le raccolte dovresti mirare a usare IEnumerable ove possibile. Questo offre la massima flessibilità ma non è sempre adatto.

Se stai lavorando all'interno di un singolo metodo (o anche in una singola classe o assembly in alcuni casi) e nessuno al di fuori vedrà quello che stai facendo, usa la pienezza di un Elenco. Ma se stai interagendo con un codice esterno, come quando stai restituendo un elenco da un metodo, allora vuoi solo dichiarare l'interfaccia senza necessariamente legarti a un'implementazione specifica, specialmente se non hai controllo su chi compila contro il tuo codice in seguito. Se hai iniziato con un tipo concreto e hai deciso di passare a un altro, anche se utilizza la stessa interfaccia, infrangerai il codice di qualcun altro a meno che non abbia iniziato con un'interfaccia o un tipo di base astratto.

Non penso che ci siano regole dure e veloci per questo tipo di cose, ma di solito seguo le linee guida per usare il modo più leggero possibile fino a quando non è assolutamente necessario.

Ad esempio, supponiamo che tu abbia una Personclasse e una Groupclasse. Un Groupesempio ha molte persone, in modo da un elenco qui avrebbe senso. Quando dichiaro l'oggetto list in Groupuserò un IList<Person>e lo creerò come a List.

public class Group {
  private IList<Person> people;

  public Group() {
    this.people = new List<Person>();
  }
}

E, se non hai nemmeno bisogno di tutto IList, puoi sempre usarlo IEnumerableanche. Con i moderni compilatori e processori, non penso che ci sia davvero alcuna differenza di velocità, quindi questa è più solo una questione di stile.

Molto spesso è meglio utilizzare il tipo utilizzabile più generale, in questo caso l'IList o anche meglio l'interfaccia IEnumerable, in modo da poter passare comodamente l'implementazione in un secondo momento.

Tuttavia, in .NET 2.0, c'è una cosa fastidiosa: IList non ha un metodo Sort () . È invece possibile utilizzare un adattatore in dotazione:

ArrayList.Adapter(list).Sort()

Dovresti usare l'interfaccia solo se ne hai bisogno, ad esempio, se il tuo elenco viene trasmesso a un'implementazione di IList diversa da Elenco. Ciò vale quando, ad esempio, si utilizza NHibernate, che esegue il lancio di IList in un oggetto bag NHibernate durante il recupero dei dati.

Se Elenco è l'unica implementazione che utilizzerai mai per una determinata raccolta, sentiti libero di dichiararla come un'implementazione concreta di Elenco.

In situazioni in cui mi imbatto di solito, raramente utilizzo direttamente IList.

Di solito lo uso solo come argomento di un metodo

void ProcessArrayData(IList almostAnyTypeOfArray)
{
    // Do some stuff with the IList array
}

Ciò mi consentirà di eseguire elaborazioni generiche su quasi tutti gli array nel framework .NET, a meno che non utilizzi IEnumerable e non IList, che a volte accade.

Dipende davvero dal tipo di funzionalità di cui hai bisogno. Suggerirei di utilizzare la classe List nella maggior parte dei casi. IList è la soluzione migliore quando devi creare un array personalizzato che potrebbe avere alcune regole molto specifiche che vorresti incapsulare in una raccolta in modo da non ripetere te stesso, ma vuoi comunque che .NET lo riconosca come un elenco.

L'oggetto AList ti consente di creare un elenco, aggiungere elementi, rimuoverlo, aggiornarlo, indicizzarlo e così via. L'elenco viene utilizzato ogni volta che desideri un elenco generico in cui specifichi il tipo di oggetto in esso e il gioco è fatto.

D'altra parte IList è un'interfaccia. Fondamentalmente, se si desidera creare il proprio tipo di Elenco, pronunciare una classe elenco denominata Elenco libri, è possibile utilizzare l'interfaccia per fornire metodi e struttura di base alla nuova classe. IList è per quando si desidera creare la propria sottoclasse speciale che implementa Elenco.

Un'altra differenza è: IList è un'interfaccia e non può essere istanziato. L'elenco è una classe e può essere istanziato. Significa:

IList<string> MyList = new IList<string>();

List<string> MyList = new List<string>