Introduction

In C#, you cannot override a getter-only property in a derived class and “add” a setter if the base property contract does not include one. The reason is substitutability and metadata contract consistency. Consumers typed as the base class must see the same property shape (get only) regardless of runtime derived type.

This often surprises developers designing extensible models. The fix is usually to redesign the abstraction rather than trying to mutate property accessibility in overrides.

Core Sections

1. Base contract defines accessor surface

1public abstract class Base
2{
3    public abstract string Name { get; }
4}

Derived override must match available accessors.

1public class Derived : Base
2{
3    public override string Name { get; } = "x";
4}

2. Why adding setter violates expectations

If base references expose getter only, allowing derived-only setter would create inconsistent API semantics at compile-time vs runtime.

Base b = new Derived();
// b.Name = "new"; // impossible by base contract

C# prevents this mismatch by design.

3. Alternatives: protected setter in base

1public abstract class Base
2{
3    public virtual string Name { get; protected set; } = string.Empty;
4}

Now derived classes can set internally while external callers still cannot.

4. Alternative: method-based mutation

1public abstract class Base
2{
3    public abstract string Name { get; }
4    public abstract void Rename(string value);
5}

Explicit mutation methods can enforce validation invariants better than public setters.

5. Use new carefully (not override)

You can hide property with new, but this is usually confusing.

1public class Derived : Base
2{
3    public new string Name { get; set; } = "x";
4}

Base-typed callers still see old member; avoid this unless absolutely necessary.

6. API design guidance

If mutability may be needed by subclasses, design for it early via protected/internal setter or abstract mutation methods.

prefer explicit mutability strategy over member hiding tricks

Common Pitfalls

• Attempting to widen accessor set in override and expecting compiler to allow it.
• Using new property hiding and introducing hard-to-debug member-resolution behavior.
• Designing immutable base APIs then requiring mutable derived behavior later.
• Exposing public setters where invariants require controlled mutation.
• Ignoring base-type consumer perspective when defining extensibility contracts.

Summary

You cannot override a getter-only property and add a setter in C# because override contracts must preserve base accessor shape. To support derived mutation, redesign the base abstraction with protected/internal setter or explicit mutator methods. Clear contract planning avoids brittle inheritance patterns and confusing API behavior.

A practical way to make this topic robust in real systems is to define behavior contracts explicitly and test them at boundaries, not only in happy-path unit tests. For why is it impossible to override a getter-only property and add a setter, start by documenting the accepted input forms, normalization rules, and expected outputs in edge conditions such as null values, empty collections, malformed payloads, and partial failures. Then add representative fixtures from production logs so tests reflect the real data shape rather than idealized samples. This approach catches compatibility problems early when dependencies, framework versions, or infrastructure defaults change. It also improves onboarding because new contributors can understand the rules without reverse-engineering implicit behavior from scattered call sites.

Operationally, pair implementation changes with lightweight observability so regressions are visible before they become incidents. Emit structured diagnostics around decision points with stable field names for version, environment, execution path, and outcome. Keep sensitive values redacted, but preserve enough context to trace failures quickly. During post-incident reviews, convert each root cause into a permanent regression test and a short runbook update. Over time this creates compounding reliability: fewer repeated bugs, faster triage, and safer refactoring. For teams maintaining why is it impossible to override a getter-only property and add a setter across multiple services, centralizing shared helper logic and validating compatibility in CI before rollout usually delivers the biggest reduction in operational noise.

As a final engineering practice, keep one small benchmark or smoke test dedicated to this topic and run it in CI on dependency updates. That single guard often catches behavior drift before users notice it, and it gives maintainers a fast signal when a framework upgrade changes defaults or execution semantics.