Question

This question came up in the comments of this answer. The inability to have readonly properties was proposed as a potential reason to use fields instead of properties.

For example:

class Rectangle
{
   private readonly int _width;
   private readonly int _height;

   public Rectangle(int width, int height)
   {
      _width = width;
      _height = height;
   }

   public int Width { get { return _width; } }
   public int Height { get { return _height; } }
}

But why can’t you just do this?

public int Width { get; readonly set; }

Edit (clarification): You can achieve this functionality in the first example. But why can’t you use the auto-implemented property shorthand to do the same thing? It would also be less messy, since you wouldn’t have to directly access the fields in your constructor; all access would be through the property.

Edit (update): As of C# 6.0, readonly properties are supported! object MyProp { get; } This property can be set inline (object MyProp { get; } = ...) or in the constructor, but nowhere else (just like readonly fields).

Answer 1

Because the language doesn’t allow it.

This may seem like a frivolous answer: after all, the language designers could have declared that if you used readonly on an automatic property then it would mean “the property is settable but only in the constructor”.

But features don’t come for free. (Eric Gunnerson expresses it as “Every feature starts with minus 100 points.”) To implement read-only automatic properties would have required additional compiler effort to support the readonly modifier on a property (it currently applies only to fields), to generate the appropriate backing field and to transform sets of the property to assignments to the backing field. That’s quite a bit of work to support something that the user could do reasonably easily by declaring a readonly backing field and writing a one-line property getter, and that work would have a cost in terms of not implementing other features.

So, quite seriously, the answer is that either the language designers and implementers either never thought of the idea, or — more likely — they thought it would be nice to have, but decided there were better places to spend their finite resources. There’s no technical constraint that prevents the language designers and implementers providing the feature you suggest: the reasons are more about the economics of software development.