C#/.NET equivalente per le raccolte Java. <T> emptyList()?

Question

Qual è il modo standard per ottenere un elenco digitato, a sola lettura, vuoto in C# o ce n'è uno?

ETA: Per chi chiede "perché?": Ho un metodo virtuale che restituisce un IList (o meglio, post-risposte, un IEnumerable), e l'implementazione di default è vuoto. Qualunque cosa ritorni sulla lista dovrebbe essere di sola lettura perché scrivere su di essa sarebbe un bug, e se qualcuno ci prova, voglio fermarmi e prendere fuoco immediatamente, piuttosto che aspettare che il bug si mostri in qualche modo in un secondo momento.

Answer 1

Personalmente, credo che questo è meglio di qualsiasi delle altre risposte:

static readonly IList<T> EmptyList = new T[0]; 

• Array implementano IList<T>.
• Non è possibile aggiungere a un array.
• Non è possibile assegnare a un elemento in un array vuoto (perché lo è nessuno).
• Questo è, a mio avviso, molto più semplice di new List<T>().AsReadOnly().
• È ancora possibile restituire un IList<T> (se lo si desidera).

Per inciso, questo è quello che Enumerable.Empty<T>() utilizza effettivamente sotto il cofano, se ricordo correttamente. Quindi in teoria potresti anche fare (IList<T>)Enumerable.Empty<T>() (anche se non vedo alcuna ragione per farlo).

Answer 2

Si può solo creare un elenco:

List<MyType> list = new List<MyType>(); 

Se si desidera un vuoto IEnumerable<T>, utilizzare Enumerable.Empty<T>():

IEnumerable<MyType> collection = Enumerable.Empty<MyType>(); 

Se veramente si vuole un lista di sola lettura, si potrebbe fare:

IList<MyType> readonlyList = (new List<MyType>()).AsReadOnly(); 

Questo restituisce un ReadOnlyCollection<T>, che implementa IList<T>.

Answer 3

IList<T> list = new List<T>().AsReadOnly(); 

Oppure, se si vuole un IEnumerable<>:

IEnumerable<T> sequence = Enumerable.Empty<T>(); 

Answer 4

Che dire:

readonly List<T> mylist = new List<T>(); 

Non certo perché si vuole che in sola lettura; questo non ha molto senso nella maggior parte degli scenari che riesco a pensare, però.

Answer 5

Se si desidera un elenco il cui contenuto non può essere modificato, si può fare:

ReadOnlyCollection<Foo> foos = new List<Foo>().AsReadOnly(); 

Answer 6

costruire un'istanza di System.Collections.ObjectModel.ReadOnlyCollection dalla vostra lista.

List<int> items = new List<int>(); 
ReadOnlyCollection<int> readOnlyItems = new ReadOnlyCollection<int>(items); 

Answer 7

Per espandere su Dan Tao's answer, la seguente implementazione può essere utilizzata allo stesso modo di Enumerable.Empty<T>(), specificando invece List.Empty<T>().

public static class List 
{ 
    public static IList<T> Empty<T>() 
    { 
     // Note that the static type is only instantiated when 
     // it is needed, and only then is the T[0] object created, once. 
     return EmptyArray<T>.Instance; 
    } 

    private sealed class EmptyArray<T> 
    { 
     public static readonly T[] Instance = new T[0]; 
    } 
} 

Edit: ho cambiare il codice di cui sopra in modo da riflettere il risultato di una discussione con Dan Tao circa pigri contro l'inizializzazione desiderosi del campo Instance.

Answer 8

Partendo .net 4.6 è anche possibile utilizzare:

IList<T> emptyList = Array.Empty<T>(); 

Questo non solo creare una nuova istanza una volta per ogni diverso tipo specificato come T.