Come consentire l'iterazione su una raccolta privata ma non la modifica?

Question

Se ho il seguente membro della classe:

private List<object> obs; 

e voglio permettere l'attraversamento di questa lista come parte dell'interfaccia di classe, come lo farei?

Rendendolo pubblico non funzionerà perché non voglio permettere che l'elenco venga modificato direttamente.

Answer 1

Si potrebbe esporlo come un IEnumerable<T>, ma non solo di tornare direttamente:

public IEnumerable<object> Objects { get { return obs.Select(o => o); } } 

Dal momento che hai indicato che si voleva solo attraversamento della lista, questo è tutto ciò che serve.

Si potrebbe essere tentati di restituire il List<object> direttamente come IEnumerable<T>, ma sarebbe errato, in quanto si potrebbe facilmente controllare l'IEnumerable<T> in fase di esecuzione, determinare è un List<T> e gettarlo ai quali e mutare il contenuto.

Tuttavia, utilizzando return obs.Select(o => o); si finisce per restituire un iteratore su List<object>, non un riferimento diretto allo stesso List<object>.

Alcuni potrebbero pensare che questo si qualifica come "espressione degenere" in base alla sezione 7.15.2.5 della specifica del linguaggio C#. Tuttavia, Eric Lippert goes into detail as to why this projection isn't optimized away.

Inoltre, le persone suggeriscono che si usi AsEnumerable extension method. Questo non è corretto, poiché l'identità di riferimento dell'elenco originale viene mantenuta. Dalla sezione Osservazioni della documentazione:

Procedimento AsEnumerable<TSource>(IEnumerable<TSource>) ha alcun effetto se non per cambiare la fase di compilazione di origine da un tipo che implementa IEnumerable<T> a IEnumerable<T> stessa.

In altre parole, tutto ciò che fa è gettata il parametro sorgente per IEnumerable<T>, che non aiuta a proteggere l'integrità referenziale, viene restituito il riferimento originario e possono essere gettati di nuovo a List<T> e essere utilizzato per mutare la lista.

Answer 2

Avete considerato di derivare una classe da System.Collections.ReadOnlyCollectionBase?

Answer 3

È possibile utilizzare uno ReadOnlyCollection o effettuare una copia dello List e restituirlo invece (considerando la penalità delle prestazioni dell'operazione di copia). Puoi anche usare List<T>.AsReadOnly.

Answer 4

esporre un ReadOnlyCollection<T>

Answer 5

È possibile farlo in due modi:

1. sia per la conversione della lista in una collezione in sola lettura:

   new System.Collections.ObjectModel.ReadOnlyCollection<object>(this.obs) 
   

2. O restituendo un IEnumerable di gli articoli:

   this.obs.AsEnumerable() 
   

Answer 6

Post interessante e dialogo su questo stesso numero: http://davybrion.com/blog/2009/10/stop-exposing-collections-already/.

Answer 7

alla vostra interfaccia di aggiungere il metodo seguente firma: pubblico IEnumerable TraverseTheList()

implimented come così:

public IEnumerable<object> TraverseTheList() 
{ 

    foreach(object item in obj) 
    { 
     yield return item; 
    } 


} 

che vi permetterà di effettuare le seguenti operazioni:

foreach(object item in Something.TraverseTheList()) 
{ 
// do something to the item 
} 

Il rendimento yield indica al compilatore di creare un enumeratore per te.

Answer 8

Questo è già stato detto, ma non vedo nessuna delle risposte come superclear.

Il modo più semplice è quello di restituire semplicemente un ReadOnlyCollection

private List<object> objs; 

public ReadOnlyCollection<object> Objs { 
    get { 
     return objs.AsReadOnly(); 
    } 
} 

Lo svantaggio di questo è che, se si desidera modificare l'implementazione in seguito, quindi alcuni chiamanti potrebbero già essere dipendente dal fatto, che la la raccolta fornisce l'accesso casuale. Quindi, una definizione più sicuro sarebbe quello di esporre solo un IEnumerable

public IEnumerable<object> Objs { 
    get { 
     return objs.AsReadOnly(); 
    } 
} 

Si noti che non c'è bisogno di chiamare AsReadOnly() per compilare il codice. Ma se non lo fai, il chiamante mi limita a restituire il valore restituito a un elenco e a modificare l'elenco.

// Bad caller code 
var objs = YourClass.Objs; 
var list = objs as List<object>; 
list.Add(new object); // They have just modified your list. 

Lo stesso potenziale problema esiste anche con questa soluzione

public IEnumerable<object> Objs { 
    get { 
     return objs.AsEnumerable(); 
    } 
} 

Quindi senz'altro consiglio che si chiama AsReadOnly() su di voi la lista, e restituire tale valore.