Как сделать свойство ссылочного типа “только для чтения”

Если Вы не хотите, чтобы кто-либо смешал с Вашим состоянием... не выставляют его! Как другие сказали, если что-то должно просмотреть Ваше внутреннее состояние, обеспечьте неизменное представление его. С другой стороны, заставьте клиенты говорить Вам делать что-то (Google для "говорят, не спрашивают"), вместо того, чтобы делать его сами.

К сожалению, нет никакого простого способа вокруг этого в C# в данный момент. Вы могли извлечь "часть только для чтения" Foo в интерфейсе и позволяют Вашему возврату свойства это вместо Foo.

Делая копию, a ReadOnlyCollection, или наличие Foo будьте неизменны, обычно эти три оптимальных маршрута, поскольку Вы уже размышляли.

Я иногда одобряю методы вместо свойств каждый раз, когда я делаю что-либо более значительное, чем простой возврат базового поля, в зависимости от того, сколько работы включено. Методы подразумевают, что что-то продолжается, и повысьте больше флага для потребителей, когда они используют Ваш API.

"Клонирование" Foo возражает, что Вы получаете и отдаете, нормальная практика, названная защитным копированием. Если нет некоторый невидимый побочный эффект к клонированию, которое будет видимо пользователю, нет абсолютно никакой причины НЕ сделать это. Это часто - единственный способ защитить внутренние частные данные Ваших классов, особенно в C# или Java, где идея C++ const не доступно. (IE, это должно быть сделано для надлежащего создания действительно неизменных объектов на этих двух языках.)

Просто для уточнения возможные побочные эффекты были бы вещами как Ваш пользователь (обоснованно) ожидающий, что исходный объект быть возвращенным, или некоторый ресурс, сохраненный Foo, который не будет клонирован правильно. (В этом случае, что это делает реализацию IClonable?!)

Для разъяснения комментария Jon Skeet, можно сделать представление, которое является неизменным классом обертки для изменяемого Foo. Вот пример:

class Foo{
 public string A{get; set;}
 public string B{get; set;}
 //...
}

class ReadOnlyFoo{
  Foo foo; 
  public string A { get { return foo.A; }}
  public string B { get { return foo.B; }}
}

Можно на самом деле воспроизвести поведение константы C++ в C# - просто необходимо сделать это вручную.

Без разницы Foo единственный способ, которым вызывающая сторона может изменить его состояние, вызывающими методами для него или свойствами установки.

Например, Foo имеет тип FooClass:

class FooClass
{
    public void MutateMyStateYouBadBoy() { ... }

    public string Message
    {
        get { ... }
        set { ... }
    }
}

Таким образом в Вашем случае, Вы рады за них добраться Message свойство, но не набор это, и Вы определенно не довольны ими называющий тот метод.

Поэтому определите интерфейс, описывающий, что им позволяют сделать:

interface IFooConst
{
    public string Message
    {
        get { ... }
    }
}

Мы не учли метод видоизменения и только уехали в методе считывания на свойстве.

Затем добавьте что интерфейс к основному списку FooClass.

Теперь в Вашем классе с Foo свойство, у Вас есть поле:

private FooClass _foo;

И метод считывания свойства:

public IFooConst Foo
{
    get { return _foo; }
}

Это в основном воспроизводит вручную точно что C++ const ключевое слово сделало бы автоматически. В терминах psuedo-C++, ссылке типа const Foo & похож на автоматически сгенерированный тип, который только включает тех членов Foo это было отмечено как const участники. Переводя это в некоторую теоретическую будущую версию C#, Вы объявили бы FooClass как это:

class FooClass
{
    public void MutateMyStateYouBadBoy() { ... }

    public string Message
    {
        get const { ... }
        set { ... }
    }
}

Действительно все, что я сделал, объединяется информация в IFooConst назад в FooClass, путем меток одного безопасного участника с новым const ключевое слово. Таким образом в некотором смысле, добавление ключевого слова константы не добавило бы много к языку помимо формального подхода к этому шаблону.

Затем, если у Вас был a const ссылка на a FooClass объект:

const FooClass f = GetMeAFooClass();

Вы только смогли бы обратиться к участникам константы f.

Отметьте это если FooClass определение общедоступно, вызывающая сторона могла бросить IFooConst в a FooClass. Но они могут сделать это в C++ также - он отозван, "бросив const"и включает названный специальный оператор const_cast<T>(const T &).

Существует также проблема интерфейсов, не являющихся очень легким развиться между версиями Вашего продукта. Если третье лицо может реализовать интерфейс, Вы определяете (который они свободны сделать, если они видят его), то Вы не можете добавить новые методы к нему в будущих версиях, не требуя, чтобы другие перекомпилировали их код. Но это - только проблема, если Вы пишете расширяемую библиотеку для других для построения. Возможно, встроенное const функция решила бы эту проблему.