When should use Readonly and Get only properties

Question

In a .NET application when should I use "ReadOnly" properties and when should I use just "Get". What is the difference between these two.

private readonly double Fuel= 0;

public double FuelConsumption
         {
            get
            {
               return Fuel;
            }
         }

or

private double Fuel= 0;

public double FuelConsumption
         {
                get
                {
                   return Fuel;
                }
             }

Answer 1

Methods suggest something has to happen to return the value, properties suggest that the value is already there. This is a rule of thumb, sometimes you might want a property that does a little work (i.e. Count), but generally it's a useful way to decide.

Answer 2

Note: If you set it readonly, you cannot change its value within the class methods.

Answer 3

A property that has only a getter is said to be readonly. Cause no setter is provided, to change the value of the property (from outside).

C# has has a keyword readonly, that can be used on internal variables (not properties). A variable that is marked as "readonly", can only be set once during the construction of an object (in the constructor).

private string _name = "Foo"; // variable for property Name;
private bool _enabled = false; // variable for property Enabled;

public string Name{ // This is a readonly property.
  get {
    return _name;  
  }
}

public bool Enabled{ // This is a read- and writeable property.
  get{
    return _enabled;
  }
  set{
    _enabled = value;
  }
} 

Answer 4

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 once (using an inline assignment or in the class constructor). 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 contruction, and will never changed later on.

In short, if you need to ensure your property value will never be changed from outside, but you need to be able to change it from 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.