Is there any reason to avoid private getters?

Question

Even though I could write something like this (In C#. There are, of course, equivalents in other languages):

public int SomeNumber { private get; set; }

I have never encountered something like this. Is there any particular reason?

---

Edit: The question has been suggested as duplicated of Private setters and getters. The question there is about using properties as fields (private getters and setters):

However, any property that shouldn't be accessed from outside the object I simply designate those setters/getters as protected.

My question is not a duplicate since it is about properties with private getters and public setters.

Answer 1

I see such code often, and I do not like it.

My colleagues often use that for injecting some dependencies into an instance. But by doing so, they open up that property for change some when later on, while the property is expected to be set during object creation only.

And that's the reason why I do not like it: you cannot be sure that the public setter gets called later, and changes state of the instance which you thought was stable.

That is, when it is meant for dependency injection, use way of a proper dependency injection at object creation. If it is meant for changing the state of the instance, better use a method ("command") to infer that purpose.

Answer 2

The reason you have never seen this before is not because such code would cause any immediate problems. The reason is probably: this combination is not particular useful.

Code which makes setters public allows calling code to change the object's state, then the calling code "knows" already the content of what was passed into through the setter, and there is simply no point in "hiding" this content from the outside by making the getter private. So there is not much benefit from that, quite the opposite, testing the object's state or reusing the object gets typically harder.

Compare this, for example, with the combination of a private setter together with a public getter. This often very useful for restricting or preventing unwanted side effects, and it is required when designing immutable objects.