How is a property without a set allowed (read-only property) is being set inside the class? What mechanism?

Question

First of all, I'm NOT really familiar with C#, but I am with C++. I didn't find any info about this. Through what mechanism is a C# property is being set when it only have a get implemented and the set is hidden. It's a read-only property that is being set continuously, inside a loop.

My hunch is that the get returns a reference which C# uses to set the value in this case. Is that correct?

(I've come across a code which I'm trying to understand)

For example:

public Series<double> Avg
{
    get { return Values[1]; }
}

public Series<double> Default
{
    get { return Values[0]; }
}

(Series is just an array of doubles, but accessing them from the end of the array, by index)

The code in RSI does write the items of the array:

Default[0]  = value0;
Avg[0]      = constant1 * value0 + constant2 * Avg[1];

So what is happening up there? Just to understand, it is something like the below C++ code?

double& Avg(int index)
{
    return Values[index+1];
}

Certainly, in C++ you would use Avg(1) instead of Avg[1] since it is a function, I'm just curious what the logic actually does in @RSI.cs. Is the get in this case is like a reference so it can also write values via the get or is the set is auto-implemented so writing and reading the above properties is accessing a completely different index or even variable?

Are the above C# samples even a valid C# code?

Answer 1

That means you can only read the value of the property but not write it from the outside.

Take a file class for example. It would have a property FileSize that you could read from the outside. It would make no sense to have a Setter since setting the file size should not be possible (you have to modify the content of the file in order for the file size to change).

You would then implement a read only property in the form of the following:

public long FileSize { get { return Content.Length; } }

You can compare a C# property to a set of C++ methods. A get would be a getProperty() method in your C++ class and a set would be a setProperty(value). A C# property is actually not very different from having a field and two methods. The whole get and set is just a nice way to let the compiler generate this for you.

Answer 2

This means that this is a property that you want it to be read from outside the object without modifying it, for example you can do this:

public class MyObject
{
    private string _currentState;//This will be changed only from inside class
    public string MyCurrentState
    {
       get
       {
         return _currentState;
       }
    }
}

Answer 3

Since you are more familiar with c++, let me try to translate it somehow. Forgive me any detail errors because it's been some time since I used C++ on a regular basis.

template<class T> class Series
{
    // some template class definition

    // the index operator in c++
    T& operator [](int idx) 
    {
        return somePrivateTArray[idx];
    }
}

class UserOfSeries
{
    Series<double> Values[]; // = ... somewhere

public:
    Series<double>& Avg()
    {
        return Values[1];
    }

    Series<double>& Default()
    {
        return Values[0];
    }
}

When you use it, you will probably write

UserOfSeries* aUserOfSeries = getUserOfSeriesFromTheSystem();
Series<double>& theAvg = aUserOfSeries->Avg();
theAvg[4] = 12000.000;

Answer 4

You can set a property without a set. It only means you cannot access it from outside the class (visibility). Inside the class, the get acts as a reference as I write the values, so setting happens throughout the get if you will.

It means that my original C++ example is correct but a more accurate one is (by Rotem) std::vector& GetAvg() { return Values[0]; } so writing happens like this: GetAvg()[0] = ...;

Thank you Oliver and Rotem for your effort in trying understanding my answer. I feel like this is a good and supporting community. The ones who misunderstood my question as a visibility question were downvoting this though :-)