When Should an Attribute Be Private and Made a Read-Only Property

When should an attribute be private and made a read-only property?

Generally, Python programs should be written with the assumption that all users are consenting adults, and thus are responsible for using things correctly themselves. However, in the rare instance where it just does not make sense for an attribute to be settable (such as a derived value, or a value read from some static datasource), the getter-only property is generally the preferred pattern.

When should use Readonly and Get only properties

Creating a property with only a getter makes your property read-only for any code that is outside the class.

You can however change the value using methods provided by your class :

public class FuelConsumption {
    private double fuel;
    public double Fuel
    {
        get { return this.fuel; }
    }
    public void FillFuelTank(double amount)
    {
        this.fuel += amount;
    }
}

public static void Main()
{
    FuelConsumption f = new FuelConsumption();

    double a;
    a = f.Fuel; // Will work
    f.Fuel = a; // Does not compile

    f.FillFuelTank(10); // Value is changed from the method's code
}

Setting the private field of your class as readonly allows you to set the field value only in the constructor of the class (using an inline assignment or a defined constructor method).
You will not be able to change it later.

public class ReadOnlyFields {
    private readonly double a = 2.0;
    private readonly double b;

    public ReadOnlyFields()
    {
        this.b = 4.0;
    }
}

readonly class fields are often used for variables that are initialized during class construction, and will never be changed later on.

In short, if you need to ensure your property value will never be changed from the outside, but you need to be able to change it from inside your class code, use a "Get-only" property.

If you need to store a value which will never change once its initial value has been set, use a readonly field.

What is the definition of a read-only property in JavaScript? What does it mean?

A read-only property means it cannot be overwritten or assigned to. Any such assignment will silently do nothing in non-strict mode. E.g.:

var obj = {};
Object.defineProperty(obj, 'property', {value: 123, writeable: false})

// Assign 456 to obj.property using the . syntax, but it's still 123
obj.property = 456;
console.log(obj.property);

// Assign 789 to obj.property using the [] syntax, but it's still 123
obj['property'] = 789;
console.log(obj['property']);

How to create a read-only class property in Python?

The property descriptor always returns itself when accessed from a class (ie. when instance is None in its __get__ method).

If that's not what you want, you can write a new descriptor that always uses the class object (owner) instead of the instance:

>>> class classproperty(object):
...     def __init__(self, getter):
...         self.getter= getter
...     def __get__(self, instance, owner):
...         return self.getter(owner)
... 
>>> class Foo(object):
...     x= 4
...     @classproperty
...     def number(cls):
...         return cls.x
... 
>>> Foo().number
4
>>> Foo.number
4

Readonly property vs. readonly member variable in C#

Yes, the readonly keyword means that the field can be written to only in a field initializer and in constructors.

If you want, you can combine readonly with the property approach. The private backing field for the property can be declared readonly while the property itself has only a getter. Then the backing field can be assigned to only in constructors (and in its possible field initializer).

Another thing you could consider is making a public readonly field. Since the field itself is read-only, you actually don't achieve much from the getter if all it does is returning the field value.

ReadOnly Property or property with private set I should use in vb.net?

In the case of ReadOnly, only those with access to the underlying variable may change the underlying value (i.e. elements within the same class, for instance) by directly applying such a change. In the latter case, Private Set - this is much the same - elements within the scope of the class can change the underlying value, but can do so by means of the property.

Which one is preferred is circumstantial: one advantage of properties is that you can, like a method, have further implementation involved when applying the change (although side-effects should be avoided, you might 'validate' and take exception, for instance). If there is always something else to do when setting the value, that is strongly related to setting the value, you might do it within this property setter, as opposed to having to code that implementation everywhere you do the set.

Set a read only property defined in a interface within a concrete class

This doesn't have anything to do with the interface, you're just declaring the property incorrectly. In C# 6, you can create a read-only property like this:

public class Person : IPerson
{
    public Person()
    {
        Name = "Person";
    }

    public string Name { get; }
}

In earlier versions, you can use a read-only backing field which you can set:

public class Person : IPerson
{
    private readonly string _name;

    public Person()
    {
        _name = "Person";
    }

    public string Name
    {
        get { return _name; }
    }
}

Note that the interface only requires the property has a getter, the implementation doesn't have to be read-only. You could add a setter if you had reason to modify the value:

public class Person : IPerson
{
    public Person()
    {
        Name = "Person";
    }

    public string Name { get; set; }
}

The setter could be private if you only needed to be able to change the value from within the class.

How to define a read-only persistent property

public class Client : XPObject {
    [Persistent("ClientID")]
    private string clientID;

    [PersistentAlias("clientID")]
    public string ClientID {
        get { return clientID; }
    }

    public Client(string clientID) {
        this.clientID = clientID;
    }

    public Client(Session session) : base(session) {}
}

Note You can make your object's property "read-only" just for bound visual controsl, e.g. TextEdit. All you need is to decorate your property or public field with the ReadOnly attribute

readonly properties and ngOnInit

You can't mark a method as a constructor there is just no syntax for that. You can break the readonly which is just a compile time check by using a type assertion to any and access any public/private property you want in a type unsafe way. You can also use a mapped type to make the type mutable, but it only works for public properties:

type Mutable<T> = { -readonly [ P in keyof T]: T[P] }

class Foo {
    public readonly data: string;
    private readonly pdata: string;
    public init() {
        const ref: Mutable<this> = this;
        ref.data = "" 
        const pRef = this as any;
        pRef.pdata = ""

        const pSaferRef: { pdata: string } = this as any;
        pSaferRef.pdata = ""
    }
}

What are the benefits to marking a field as `readonly` in C#?

The readonly keyword is used to declare a member variable a constant, but allows the value to be calculated at runtime. This differs from a constant declared with the const modifier, which must have its value set at compile time. Using readonly you can set the value of the field either in the declaration, or in the constructor of the object that the field is a member of.

Also use it if you don't want to have to recompile external DLLs that reference the constant (since it gets replaced at compile time).

---

Related Topics