How do I use accessors?

Question

I am a complete amateur at programming and am trying to learn proper code design. I`m trying to learn how to use accessors but can't seem to get it to run properly. This is what I am trying to run:

class Classy
    {
        public void changeLine(string change)
        {
            Form1 form1 = new Form1();
            form1.Line = change;
        }
    }

public partial class Form1 : Form
    {
        string line = "";
        public string Line
        {
            get
            {
                return line;
            }
            set
            {
                line = value;
            }
        }
        private void button2_Click(object sender, EventArgs e)
        {
            line = "";
            string change = "cake";
            Classy classy = new Classy();
            classy.changeLine(change);
            MessageBox.Show(line);
        }

When I click the button, it shows blank text. From what I understand these are the steps it take:

1. variable change with "cake" value is passed to classy's changeLine method.
2. changeLine method sets Form1 line to variable change with "cake" value.
3. MessageBox displays line variable of "cake" value.

Why does this not work?

Answer 1

This is happening because you are creating a new instance of Form on the changeLine method. This new instance is different from the one the event was fired, or the button was clicked.

In order to use the correct Form reference, you may pass the actual reference as an argument:

public void changeLine(Form1 form, string line) {
    form.Line = line;
}

You would call this method (from the form) like this:

classy.changeLine(this, change);

this is the current Form1 instance, it is the one you want to modify. You don't want to create a new one.

Answer 2

Okay. You've got a Form1 object and the window it represents and controls is displayed on screen. You click a button and it invokes a method.

line = "";

This line is a private field which happens to be the backing field to the Line property. At this point accessing either the line field or the Line property will return "".

string change = "cake";

A string local to this method.

Classy classy = new Classy();

Okay, we've a new object of type Classy called classy.

classy.changeLine(change);

Let's look at what this call does:

Form1 form1 = new Form1();

You now have a different Form1 object. If you called form1.Show() you would now have two windows on the screen`.

form1.Line = change;

Sets the Line property (and hence the line field) of this new, different Form1.

We now return back to the calling method:

MessageBox.Show(line);

Shows the value of the line field of the original Form1 object.

To demonstrate a property being set from outside the class you could do something like:

class Classy
{
    public void changeLine(Form1 form1, string change)
    {
        form1.Line = change;
    }
}

public partial class Form1 : Form
{
    string line = "";
    public string Line
    {
        get
        {
            return line;
        }
        set
        {
            line = value;
        }
    }
    private void button2_Click(object sender, EventArgs e)
    {
        string change = "cake";
        Classy classy = new Classy();
        classy.changeLine(this, change);
        MessageBox.Show(line);
    }
}

Here because the Form1 passes itself (this refers to the object of the method running) to classy its own Line property will now be used.

Alternatively:

class LineStorer
{
    private string _line;
    public string Line
    {
        get { return _line; }
        set { _line = value; }
    }
}

public partial class Form1 : Form
{
    private void button2_Click(object sender, EventArgs e)
    {
        var storer = new LineStorer();
        storer.Line = "cake";
        MessageBox.Show(storer.Line);
    }
}

Here the form is first setting and then getting a property in another object.

Note also that objects can use their own properties instead of the backing field:

public partial class Form1 : Form
{
    private string _line;
    public string Line
    {
        get { return _line; }
        set { _line = value; }
    }
    private void button2_Click(object sender, EventArgs e)
    {
        Line = "cake";
        MessageBox.Show(Line);
    }
}

From the inside, so to speak, there's really not much difference whether one uses a field or a property, but using properties does have an advantage in that if some day you changed from this simpler property (read and write from and to a field and do nothing else) to one that is more complicated (common cases including validation checks on all setting, but you are far from limited to that) then you'd only have to change the one place where the property is defined rather than the, perhaps very many, places where it is used.

(It may seem like using Line is more work than just using line, because it does after all call into more code, and therefore using properties rather than fields would be a slight inefficiency that would add up over time. Luckily the jitter is smart enough to "inline" simple getters and setters when the code is run, so there is in fact no cost to them).