What is the purpose of accessors?

Can somebody help me understand the get & set? Why are they needed? I can just make a public variable.

What are properties?

Properties are language elements that allow you to avoid the repetitive getXYZ() accessors and setXYZ() mutators techniques found in other languages, like Java.

Why do they exist?

They aim to solve the following problems:

1. Saying get and set in the beginning of every access or mutation of a value is annoying and distracting.
   In Java, you often say:

   class person
   {
       private int _age;
       public void setAge(int value) { /*check value first, then set _age*/ }
       public int getAge() { return this._age; }
   }

   and then consistently say:

   if (person.getAge() > blah || person.getAge() < 10)
   {
       person.setAge(5);
   }

   After a while, the get and set become rather annoying.
2. Providing direct access to the actual variable breaks encapsulation, so that's not an option.

How are they used?

They are used just like variables. You read/write to them just like variables.

How are they created?

They are created as methods. You define a pair of methods that:

1. Return the current value of the property. Oftentimes, this is nothing more than something like the following:

   class Person
   {
       private int _age; //Declare the backing field
   
       public int Age
       {
           get { return this._age; }
           set { ... }
       }
   }

2. Set the value of the property:

   class Person
   {
       public int Age
       {
           get { ... }
           set
           {
               if (value < 0) //'value' is what the user provided
               { throw new ArgumentOutOfRangeException(); } //Check validity
               this._age = value;
           }
       }
   }

Other notes:

Auto-implemented Properties

C# 3.0 introduced auto-implemented properties:

public int Age { get; set; }

This is equivalent to:

private int _age; //The name is auto-generated
public int Age { get { return this._age; } set { this._age = value; } }

Why does it exist?

It helps you avoiding breaking changes in client executables.

Let's say you're lazy and don't want to type the whole thing, and decide to expose a variable publicly. You then create an executable that reads from or writes to that field. Then you change your mind and decide that you in fact needed a property, so you change it to one.

What happens?

The depending executable breaks, because the code is no longer valid.

Auto-implemented properties help you avoid that, without extra redundancy in your initial code.

Indexers

Indexers extend the property syntax to let you index objects (surprise!), just like arrays.
For C++ users: This is similar to overloading operator [].

Example:

private int[] _elements;

public int this[int index] //Indexed property
{
    get { return this._elements[index]; }
    set
    {
        //Do any checks on the index and value
        this._elements[index] = value;
    }
}

You then use them like obj[5] = 10;, which is equivalent to calling the set method of obj's indexer.
In fact, System.Collections.Generic.List<T> is indexed:

var list = new List<int>();
list.Add(10);
list[0] = 5;  //You're indexing list, as though it were an array!

Isn't that neat? :)

Anything else?

There are many more features to properties, not all of which are available in C#:

• Parametrized properties, of which indexers are a special kind
• Getter/setter access modifiers (in C#)
• Multiple getters or setters (not in C#)
• Et cetera

Author: Mehrdad

Source: http://stackoverflow.com/questions/6554210/what-is-the-purpose-of-accessors