How do I use accessors?

Good. You have an object Form1

, and the displayed window and controls are displayed on the screen. You click a button and it calls a method.

line = "";

      

        
        
        
      

    

This line

is a private field that is a helper field for a property line

. At this point, access to the field line

or property line

will be returned ""

.

string change = "cake";

      

        
        
        
      

    

A string local to this method.

Classy classy = new Classy();

      

        
        
        
      

    

Ok, we have a new type object Classy

called Classy

.

classy.changeLine(change);

      

        
        
        
      

    

See what this call does:

Form1 form1 = new Form1();

      

        
        
        
      

    

Now you have another Form1

object. If you called form1.Show()

, you will now have two windows on your screen.

form1.Line = change;

      

        
        
        
      

    

Sets the property line

(and therefore the field line

) of this new, different Form1

.

Now back to the calling method:

MessageBox.Show(line);

      

        
        
        
      

    

Shows the field value of the originalline

object . Form1

To demonstrate a property set from outside the class, you can 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, since it Form1

passes itself ( this

refers to the object of the running method) to Classy

now its own property will be used line

.

As an alternative:

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 set and then gets 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 really isn't much difference whether a field or a property is used, but using properties has the advantage that if on some day you change that simple property (read and write from and to the field and nothing do not) for a more complex one (common cases, including check validation for all settings, but you are far from limited to that), then you will only need to change one place where the property is defined, not possibly very many places where it is used.

(It might seem like using line

is more than just using line

, because in the end it calls out more code and therefore using properties rather than fields would be a little inefficiency that would add up over time.Fortunately, jitter is smart enough. to "inline" simple getters and setters when the code is running, so there's really no cost to them).