Как мне использовать свойства при работе с участниками List, доступными только для чтения ‹T›

Вы можете открыть его AsReadOnly. То есть вернуть оболочку IList<T> только для чтения. Например ...

public ReadOnlyCollection<int> List
{
    get { return _lst.AsReadOnly(); }
}

Просто вернуть IEnumerable<T> недостаточно. Например ...

void Main()
{
    var el = new ExposeList();
    var lst = el.ListEnumerator;
    var oops = (IList<int>)lst;
    oops.Add( 4 );  // mutates list

    var rol = el.ReadOnly;
    var oops2 = (IList<int>)rol;

    oops2.Add( 5 );  // raises exception
}

class ExposeList
{
  private List<int> _lst = new List<int>() { 1, 2, 3 };

  public IEnumerable<int> ListEnumerator
  {
     get { return _lst; }
  }

  public ReadOnlyCollection<int> ReadOnly
  {
     get { return _lst.AsReadOnly(); }
  }
}

ответ Стива также есть умный способ избежать заброса.

Есть ограниченная ценность в попытках скрыть информацию до такой степени. Тип свойства должен указывать пользователям, что им разрешено с ним делать. Если пользователь решит злоупотребить вашим API, он найдет способ. Блокировка их от кастинга не останавливает их:

public static class Circumventions
{
    public static IList<T> AsWritable<T>(this IEnumerable<T> source)
    {
        return source.GetType()
            .GetFields(BindingFlags.Public |
                       BindingFlags.NonPublic | 
                       BindingFlags.Instance)
            .Select(f => f.GetValue(source))
            .OfType<IList<T>>()
            .First();
    }
}

С помощью этого единственного метода мы можем пока обойти три ответа на этот вопрос:

List<int> a = new List<int> {1, 2, 3, 4, 5};

IList<int> b = a.AsReadOnly(); // block modification...

IList<int> c = b.AsWritable(); // ... but unblock it again

c.Add(6);
Debug.Assert(a.Count == 6); // we've modified the original

IEnumerable<int> d = a.Select(x => x); // okay, try this...

IList<int> e = d.AsWritable(); // no, can still get round it

e.Add(7);
Debug.Assert(a.Count == 7); // modified original again

Также:

public static class AlexeyR
{
    public static IEnumerable<T> AsReallyReadOnly<T>(this IEnumerable<T> source)
    {
        foreach (T t in source) yield return t;
    }
}

IEnumerable<int> f = a.AsReallyReadOnly(); // really?

IList<int> g = f.AsWritable(); // apparently not!
g.Add(8);
Debug.Assert(a.Count == 8); // modified original again

Повторюсь ... такая «гонка вооружений» может продолжаться сколько угодно!

Единственный способ остановить это - полностью разорвать связь с исходным списком, что означает, что вам нужно сделать полную копию исходного списка. Это то, что делает BCL, когда возвращает массивы. Обратной стороной этого является то, что вы возлагаете потенциально большие расходы на 99,9% пользователей каждый раз, когда им нужен доступ только для чтения к некоторым данным, потому что вы беспокоитесь о хакерских действиях 00,1% пользователей.

Или вы можете просто отказаться от поддержки использования вашего API в обход системы статических типов.

Если вы хотите, чтобы свойство возвращало список только для чтения с произвольным доступом, верните то, что реализует:

public interface IReadOnlyList<T> : IEnumerable<T>
{
    int Count { get; }
    T this[int index] { get; }
}

Если (что гораздо чаще) нужно только последовательно перечислять, просто верните IEnumerable:

public class MyClassList
{
    private List<int> li = new List<int> { 1, 2, 3 };

    public IEnumerable<int> MyList
    {
        get { return li; }
    }
}

ОБНОВЛЕНИЕ. После того как я написал этот ответ, вышел C # 4.0, поэтому в указанном выше интерфейсе IReadOnlyList можно использовать преимущества ковариации:

public interface IReadOnlyList<out T>

И вот .NET 4.5 прибыл, и у него ... угадайте, что ...

интерфейс IReadOnlyList

Итак, если вы хотите создать самодокументирующийся API со свойством, содержащим список только для чтения, ответ находится в структуре.

ответ JP относительно возврата IEnumerable<int> является правильным (вы можете преобразовать его в список), но вот метод, который предотвращает преобразование вниз.

class ExposeList
{
  private List<int> _lst = new List<int>() { 1, 2, 3 };

  public IEnumerable<int> ListEnumerator
  {
     get { return _lst.Select(x => x); }  // Identity transformation.
  }

  public ReadOnlyCollection<int> ReadOnly
  {
     get { return _lst.AsReadOnly(); }
  }
}

Преобразование идентичности во время перечисления фактически создает генерируемый компилятором итератор - новый тип, который никак не связан с _lst.

Эрик Липперт опубликовал в своем блоге серию статей о неизменяемости в C #.

Первую статью из серии можно найти на здесь.

Вы также можете найти полезным Ответ Джона Скита на аналогичный вопрос.

public List<int> li;

Не объявляйте общедоступные поля, это обычно считается плохой практикой ... вместо этого оберните его в свойство.

Вы можете представить свою коллекцию как ReadOnlyCollection:

private List<int> li;
public ReadOnlyCollection<int> List
{
    get { return li.AsReadOnly(); }
}

public class MyClassList
{
    private List<int> _lst = new List<int>() { 1, 2, 3 };

    public IEnumerable<int> ListEnumerator
    {
        get { return _lst.AsReadOnly(); }
    }

}

Чтобы проверить это

    MyClassList  myClassList = new MyClassList();
    var lst= (IList<int>)myClassList.ListEnumerator  ;
    lst.Add(4); //At this point ypu will get exception Collection is read-only.

public static IEnumerable<T> AsReallyReadOnly<T>(this IEnumerable<T> source)
{
    foreach (T t in source) yield return t;
}

если я добавлю к примеру Earwicker

...
IEnumerable<int> f = a.AsReallyReadOnly();
IList<int> g = f.AsWritable(); // finally can't get around it

g.Add(8);
Debug.Assert(a.Count == 78);

Я получаю InvalidOperationException: Sequence contains no matching element.