Is there a better way of using getters and setters on private members of a class?

Question

I have this example class:

public class Carrots
{
    private string name;

    public void SetName(string pName)
    {
        name = pName;
    }

    public string GetName()
    {
        return name;
    }
}

I have the member of the class set as private and to set and get this member, I have made get and set methods. Is there a way I can make this code shorter and easier to read at a glance?

Answer 1

Using properties

A proper getter and setter would look like this:

public class Carrots
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

(Click here if you don't understand the role of the keyword value in this example).

Using auto-properties

In c# 3.0 and later, you can also use auto-properties, making it even easier.

public class Carrots
{
    public string Name { get; set; }
}

If you want the public property to be read-only (but still want a private setter) you can use:

public class Carrots
{
    public string Name { get; private set; }
}

How to call it

In both cases, you would call it like this:

var c = new Carrots();
c.Name = "This is a test!";
Console.WriteLine(c.Name); //outputs "This is a test!"

Answer 2

Shorter and easier to read would be something similar to:

public class Carrots
{
    public string Name { get; set; }
}

This uses an internal private variable that is used when the property is accessed. Equivalent to:

public class Carrots
{
    private string _name;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
}

(As @John Wu demonstrated.)

However, it will depend on what you are wanting external code to be able to access.

If you just want a 'Name' to be instantly changeable and it has no bearing on the application when it is, the above public string Name { get; set; } is all you will need.

But if you are tracking/using/controlling the value of a property within your class and you don't want external code changing it, then the second example is the one to go with.

For instance:

You have a class that is created with a known value. You want that value to be changed - but under your control.

A bank balance perhaps? Or the speed of a car?

Lets go with speed of a car:

public class Car
{
    private string _speed;

    public string Speed
    {
        get { return _speed; }
    // Notice no setter in this case.
    }

    public void IncreaseSpeed()
    {
        if(_speed + 1 <= 100)
        {
            _speed++;
        }
    }

    public void Brake()
    {
        if(_speed-- >= 0)
        {
            _speed--;
        }
    }
}

This lets the calling code call to increase speed, or slow down holding the brake, as many times as they want. But you can now put a realistic limit on that speed - the user cannot break the rules you have in you application's 'world'.

Here is another example but the external code can set the value immediately:

public class Car
{
    private string _speed;

    public string Speed
    {
        get { return _speed; }
        set {
                if (value >= 0 && value <= 100)
                {
                    _speed = value;
                }
            }
    }
}

This now lets the calling code handle acceleration and braking, updating the Car object when it wants to. But you still have the overall control of what that value can be, rather than controlling how it is changed.

Using:

public class Carrots
{
    public string name;
}

as @Charles Merriam demonstrated is all well and good if you don't care when, and to what value, external code will set this property. It is always public, and never checked when altered.

It should never be accessed by your class's internal methods if it requires boundaries as to what state it should be in or requires a particular range. You would need to use the boundary checking logic everywhere that accesses it (then handle any errors if the checks fail), rather than preventing invalid data input altogether.

Answer 3

In some instances, I use "spelled out" getters as I want something special done for the return. I came to this page looking for the syntax and did not see this use case listed so I will include in case anyone ends up here looking for the same thing. (No setter in this case as it is only for formatting a return value)

public string FullName
    {
        get {
            string mi = MiddleName.Substring(1, 1);

            StringBuilder sb = new StringBuilder();
            sb.Append(FirstName);
            sb.Append(" ");
            sb.Append(mi);
            sb.Append(" ");
            sb.Append(LastName);
            return sb.ToString();
        }
    }  

Answer 4

Just a quick few things:

• You are using getters and setters in the construct because of limitations in your language and its inability to inhibit the 'address of' operator on members.
• You are using getters and setters because there might, possibly, be a future in which you replace the data items with complex functions, and the language does not support overriding the '.' operator correctly.
• You are using getters and setters because everyone else does it, it becomes part of the lore, and part of the development schedule and executable speed bloat.

If working in a team, an alternate approach is to dump the getters and setters, use direct access to the fields, and have a chat with developer doing something stupid to the field.

So you write:

public class Carrots
{
    public string name;
}

and access as myCarrot.name