Getters and Setters versus class method

Question

I am asking about a recommendation to use getters and setters. I wrote the same code in two versions: using getters and setters and using just the class method. And I can't clearly see the difference between them.

I wrote the class Book with the private field rating. And the constructor Book can assign something to Book.rating by RatingSetter or by RatingMethod. RatingMethod only sets the values, but I can also create a method only for getting values.

class Book
    {
        public string title;
        public string author;
        private string rating;

        public Book(string title, string author, string rating)
        {
            this.title = title;
            this.author = author;
            RatingSetter = rating;
            RatingMethod(rating);
        }

        public string RatingSetter
        {
            get { return this.rating; }
            set
            {
                if (value == "PG" || value == "PG-13" || value == "R")
                {
                    rating = value;
                }
                else
                {
                    rating = "NR";
                }
            }
        }

        public string RatingMethod(string rating)
        {
            if (rating == "PG" || rating == "PG-13" || rating == "R")
            {
                return this.rating = rating;
            }
            else
            {
                return this.rating = "NR";
            }
        }
    }

In my opinion, there is no difference about security, validation or anything. Could anyone guide and help me to understand what's the difference and why is it recommended to use getters and setters.

Answer 1

Getters and setters are just syntactic sugar. The compiler will compile your getters and setters into getter and setter methods eventually. So by writing getter and setter methods yourself, you are kind of doing the job of the compiler.

Therefore, I recommend you to use getters and setters, because one of their main purposes is to replace getter and setter methods.

Here are some other advantages of using getters and setters:

• Getters and setters can save you a lot of time if you only need getters and setters without any logic:

  public int Property { get; set; }
  

• In my opinion, the aesthetic of getters and setters look better. Compare:

  obj1.Property += obj2.Property;
  

  with

  obj1.SetProperty(obj1.GetProperty() + obj2.GetProperty());
  

  I feel like the latter just has too many parentheses.

• Keep the setters and getters close to the property declaration. If you use getter and setter methods, you could accidentally write other methods between the property declaration and the getter/setter methods, causing the getter/setter methods to slowly "drift away" from the property declaration. Next time you want to find it, you need to scroll up and down. With getters and setters, they will always be below the property declaration.

Answer 2

From Microsoft,

A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field.

Which is basically their way of saying that a property is a purpose built member, that exists solely for wrapping and accessing private members, enabling the "data to be accessed easily and still helps promote the safety and flexibility of methods."

In your example, I would rename RatingSetter simply to Rating and treat it as though you would a normal public field. This promotes ease of use and lessens confusion when other people use your code. It is more obvious what you are doing and what needs to be done.

It is also not advisable to have public fields, e.g public string title; Instead it is usually better to opt for using a property to wrap this field and make it private e.g.

private string title;
public string Title {get; set;}

You can then use the public property outside of your class, but now have more control over what happens when someone accesses or sets the variable.

private string title;
public string Title {get; private set;}

Which will only allow read access from outside of the class.

Logging is now easier, since you can implement it in the setter:

private string title;
public string Title 
{
    get{ return title;}
    set
    {
        // Logging Code Here
        title = value;
    }
}

So to summarise, properties are concise and the functionality obvious, like a field, but with all the power and flexibility of a method.

Answer 3

The functionality is the same. But it makes the code more readable and understandable.

In your example you validate rating by calling RatingSetter or RatingMethod. Consider you work in a team and your co-worker doesn't know about the validation methods and simply calls this.rating = someValue. With your example there wouldn't be any validation. My code example (untested) ensures that the validation is done on every value assign.

private string rating {
     get { return this.rating; }
        set
        {
            if (value == "PG" || value == "PG-13" || value == "R")
            {
                rating = value;
            }
            else
            {
                throw new UnknownRatingException();

            }
        }
}

public Book(string title, string author, string rating)
    {
        this.title = title;
        this.author = author;
        this.rating = rating //the set property is called
    }