Limit the Write Access of a Value to Other Classes Only

[wolgemoth]

In C# the "public" keyword exposes a type or member to other classes while "private" hides it to all classes but itself.

But what if I wanted to restrict write access for a value such that only other classes can assign to it?

Example use case:

Problem:
Developers often use auto properties to create custom get/set functionality for a value, but might want to use different logic if assigning to a value from another class. In this situation, the developer creates a public auto property and modifies the backing field locally. However, the property is still exposed to the local class meaning it is possible to accidentally assign to it instead of the backing field, potentially creating a very sneaky bug.

// The default value for the counter.
private const int s_DefaultCount = 10;

// A counter that can only decrement through use of the property but the local class has its own logic for the backing field.
private int m_Counter;
public int Counter {
    get {
        return m_Counter;
    }
    set {
        if (value < m_Counter) {
            m_Counter = value;
        }
    }
}

private void ResetCounter() {
    Counter = s_DefaultCount; // Oops. Well, this bug is easy to see. But imagine this in a larger block of code!
}

Solution:
Developer marks the auto property "public only", meaning it is only writable by other classes. This resolves the ambiguity between auto properties and their backing fields.

// The default value for the counter.
private const int s_DefaultCount = 10;

// Write access to the auto property is restricted to other classes only!
private int m_Counter;
public only int Counter {
    get {
        return m_Counter;
    }
    set {
        if (value < m_Counter) {
            m_Counter = value;
        }
    }
}

private void ResetCounter() {

    m_Counter = s_DefaultCount // Correct usage. No bugs here!

    int someInt = Counter // Allowed because we still have read access just not write access.

    Counter = s_DefaultCount;  // Inaccessible due to its protection level. No more accidental bugs!
}

This is just one simple example but this type of access modifier would be extremely useful:

• Where write logic needs to be handled differently by classes other than the original.
• When assigning to a value is unneccesary (Values are initialised externally).
• When assigning to a value could/would be erroneous.
• For parallel processing.
• And so on...

[YairHalberstadt]

C# has relatively few accessibilities. Each additional accessibility massively increases complexity - not just for the compiler but for analysers and source generators as well (I have spent many hours wrangling with accessibility in StrongInject, before eventually resorting to a less than perfect solution).

I don't think I've ever needed this particular accessibility. Given how niche it is, I think it quite unlikely that it justifies the costs.

[bernd5]

The most complicated point with access modifiers is that they need to be respected in method resolution, too (method hiding) - quite complex. They do not cause just errors or warnings.

But I could imagine to add an additional attribute like [OtherTypesOnly] which could be evaluated by an analyzer to trigger a warning / error.
This seems to be easy doable with few costs.

So you could write:

using System;

//placed e.g. in System?
class OtherTypesOnlyAttribute : Attribute
{
}

class App {
    // The default value for the counter.
    private const int s_DefaultCount = 10;

    // Write access to the auto property is restricted to other classes only!
    private int m_Counter;
    public int Counter {
        get {
            return m_Counter;
        }
        [OtherTypesOnly]
        set {
            if (value < m_Counter) {
                m_Counter = value;
            }
        }
    }

    private void ResetCounter() {

        m_Counter = s_DefaultCount; // Correct usage. No bugs here!

        int someInt = Counter; // Allowed because we still have read access just not write access.

        Counter = s_DefaultCount;  // Inaccessible due to its protection level. No more accidental bugs!
    }
}

Currently the attribute is just ignored...

[wolgemoth]

I could imagine to add an additional attribute like [OtherTypesOnly] which could be evaluated by an analyzer to trigger a warning / error.

This seems to be easy doable with few costs.

That sounds like an excellent compromise. All the functionality that is needed is just an error to occur in the developer's code editor. Similar to how the [System.Obsolete()] attribute works.

[theunrepentantgeek]

the functionality that is needed is just an error to occur in the developer's code editor

Yup. And this functionality exists today. This kind of scenario is why Source Analysers were introduced.

[bernd5]

So I think this issue can be closed here but maybe moved e.g. to runtime \ roslyn. Or perhaps it is to special and should be implemented in a separate library?