Lista readonly z prywatnym zestawem

Jeśli chcesz używać kolekcji readonly ReadOnlyCollection<T>, nie List<T>: {]}

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

Wolę używać IEnumerable

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

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

Return a ReadOnlyCollection, która implementuje IList

private List<string> myList;

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

Istnieje kolekcja o nazwie ReadOnlyCollection<T> - tego szukasz?

Możesz użyć metody List AsReadOnly (), aby zwrócić opakowanie tylko do odczytu.

private List<string> my_list;

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

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

    public ReadOnlyCollection<string> Items

    {

        get { return _items.AsReadOnly(); }

        private set { _items = value }

    }

Here is one way

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");
        }

    }

W frameworku. NET 4.5 można wystawiać tylko interfejs IReadOnlyList. Coś w stylu:

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

Lub jeśli chcesz zapobiec niechcianemu castingowi do IList

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

private List<string> myList;

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

Dlaczego używasz listy. Brzmi jak to, co naprawdę chcesz ujawnić, to IEnumerable

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

Teraz użytkownicy klasy mogą odczytywać pozycje, ale nie chagnować listy.

Możesz również utworzyć swoją normalną listę, ale wystawić ją za pomocą właściwości typu IEnumerable

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

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

Trochę za późno, ale mimo to: nie lubię używać wrappera ReadOnlyCollection, ponieważ nadal wyświetla wszystkie metody modyfikacji kolekcji, które rzucają NotSupportedException, gdy są dostępne w run-time. Innymi słowy, implementuje interfejs IList, ale potem narusza ten sam kontrakt w czasie wykonywania.

Aby wyrazić, że naprawdę ujawniam niezmienną listę, Zwykle uciekam się do niestandardowego interfejsu IIndexable, który dodaje długość i indeks do IEnumerable (opisanego w This CodeProject Artykuł ). Jest to owijarka, tak jak powinno być zrobione w pierwszej kolejności IMHO.

Nie widziałem jeszcze tej opcji:

private List<string> myList;

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

To powinno pozwolić na ujawnienie listy tylko do odczytu.