Lista <T> solo con un conjunto privado

Question

¿Cómo puedo exponer un List<T> para que sea de solo lectura, pero se puede establecer de forma privada?

Esto no funciona:

public List<string> myList {readonly get; private set; } 

Incluso si lo hace:

public List<string> myList {get; private set; } 

todavía se puede hacer esto:

myList.Add("TEST"); //This should not be allowed 

Creo que se puede tener:

public List<string> myList {get{ return otherList;}} 
private List<string> otherList {get;set;} 

Answer 1

Creo que está mezclando conceptos.

public List<string> myList {get; private set;} 

es ya "sólo lectura". Es decir, fuera de esta clase, nada se puede ajustar myList a una instancia diferente de List<string>

Sin embargo, si desea una lista de sólo lectura como en "No quiero que la gente sea capaz de modificar la lista de contenidos ", entonces necesitas exponer un ReadOnlyCollection<string>. Puede hacerlo a través de:

private List<string> actualList = new List<string>(); 
public ReadOnlyCollection<string> myList 
{ 
    get{ return actualList.AsReadOnly();} 
} 

Tenga en cuenta que en el primer fragmento de código, otros pueden manipular la lista, pero no pueden cambiar lo lista que tiene. En el segundo fragmento, otros obtendrán una lista de solo lectura que no pueden modificar.

Answer 2

Si desea uso de la colección de sólo lectura ReadOnlyCollection<T>, no List<T>:

public ReadOnlyCollection<string> MyList { get; private set; } 

Answer 3

Hay una colección llamada ReadOnlyCollection<T> - es eso lo que está buscando?

Answer 4

Puede usar el método AsReadOnly() de List para devolver un contenedor de solo lectura.

Answer 5

¿Por qué está utilizando una lista. Suena como lo que realmente quiere exponer es IEnumerable

public IEnumerable<string> myList { get; private set; } 

Ahora los usuarios de la clase puede leer los artículos, pero no chagnge la lista.

Answer 6

También puede crear su lista de lo normal, pero mostrarse a través de una propiedad de tipo IEnumerable

private List<int> _list = new List<int>(); 

public IEnumerable<int> publicCollection{ 
    get { return _list; } 
} 

Answer 7

private List<string> my_list; 

public ReadOnlyCollection<string> myList 
{ 
    get { return my_list.AsReadOnly(); } 
    private set { my_list = value; } 
} 

Answer 8

devolver un ReadOnlyCollection, que implementa IList <>

private List<string> myList; 

public IList<string> MyList 
{ 
    get{return myList.AsReadOnly();} 
} 

Answer 9

private List<string> _items = new List<string>();   

    public ReadOnlyCollection<string> Items 

    { 

     get { return _items.AsReadOnly(); } 

     private set { _items = value } 

    } 

Answer 10

private List<string> myList; 

public string this[int i] 
{ 
    get { return myList[i]; } 
    set { myList[i] = value; } 
} 

Answer 11

yo prefiero usar IEnumerabl e

private readonly List<string> _list = new List<string>(); 

public IEnumerable<string> Values // Adding is not allowed - only iteration 
{ 
    get { return _list; } 
} 

Answer 12

Aquí es una manera

public class MyClass 
    { 
     private List<string> _myList; 
     public ReadOnlyCollection<string> PublicReadOnlyList { get { return _myList.AsReadOnly(); } } 

     public MyClass() 
     { 
      _myList = new List<string>(); 
      _myList.Add("tesT"); 
      _myList.Add("tesT1"); 
      _myList.Add("tesT2"); 

      //(_myList.AsReadOnly() as List<string>).Add("test 5"); 
     } 

    } 

Answer 13

Un poco tarde, pero sin embargo: No me gusta usar la envoltura ReadOnlyCollection porque todavía expone todos los métodos para modificar la colección, todos los cuales tiro a NotSupportedException cuando se accede en tiempo de ejecución. En otras palabras, implementa la interfaz IList, pero luego viola este mismo contrato en tiempo de ejecución.

Expresar que estoy realmente exponiendo una lista inmutable, por lo general recurrir a una interfaz personalizada IIndexable, que añade Longitud y un indexador a un IEnumerable (descrito en this CodeProject article). Es un contenedor como debería haberse hecho en primer lugar en mi humilde opinión.

Answer 14

No vi esta opción sin embargo, mencionó:

private List<string> myList; 

public List<string> MyList 
{ 
    get { return myList.AsReadOnly().ToList(); } 
} 

Esto debería permitirle a exponer una lista de sólo lectura.

Answer 15

En el marco .NET 4.5 puede exponer sólo la interfaz IReadOnlyList. Algo así como:

private List<string> _mylist; 
public IReadOnlyList<string> myList { get {return _myList;} } 

o si desea evitar que la fundición no deseada a IList

private List<string> _mylist; 
public IReadOnlyList<string> myList { get {return new List<string>(_myList);} }