Question

I got to think I don’t understand how it works.

My specific question is: Why am I allowed to set the value of a list property element when I have no setter and no backing list variable?

Let me explain. Let’s say I have a CustomerTable class with:

public List<string> Name
{
    get
    {
        var names = new List<string>();
        foreach (CustomerRow row in Rows)
        {
            name.Add(row.Name);
        }
        return names;
    }
}

The idea is to have a read-only property show the contents of a column without duplicating data in my class, since I already have a list of rows.

Anyway, my surprise comes when pieces of code like the following one are accepted by Visual Studio without claiming any kind of error (and it even allows me to compile without errors):

Name[0] = "John";

I can’t understand why this is legal. My property has no set { }, and it doesn’t even have a backing list to modify. What is this piece of code supposed to do?

Shouldn’t it work like a method? Is there really a stored list other than the one I generate each time someone “gets” it?

(I can give more details on demand and will also be grateful for any other remarks)

Answer 1

You are not setting the property, rather you are getting the property (which is a list) and then operating on it (in your example, changing its first member). If you were to try:

Name = new List<string>();

You would get the compilation error you were expecting to get. Note that since you are creating a new list every time, your Rows property remains read-only (assuming it is not exposed somewhere else). If you want to make it clear that changes to your returned collection are meaningless, you can change the type of the Name property to IEnumerable<string>:

public IEnumerable<string> Name
{
    get
    {
        return Rows.Select(row => row.name); //LINQ is more elegant here
    }
}