Question

I’ve got a program snippet here that allows the creation of an Employee object with simple properties of age, id, name and pay. Just playing around with it I noticed that

 Console.WriteLine(joe.Age+1); is my Main() method returns one, 

but Console.WriteLine(joe.Age++); returns 0. I know that the Age property, per the constructors is going to be initialized to 0, but why isn’t 1 being added with the ++ operator? EDIT: I found the source of the strange behavior. In the Age property I have empAge=Age when it should’ve been equal to value

source:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EmployeeApp
{
    class Employee
    {
        //field data
        //notice the the fields are declared as private
        //these fields are used in the constructors
        private string empName;
        private int empID;
        private float currPay;
        private int empAge;

        //properties! private field data should be accessed via public properties
        //note that properties don't use parentheses ()
        //within the set scope you see the 'value' contextual keyword
        //it represents the value being assigned by the caller and it will always be the same 
        //underlying data type as the property itself
        public int Age
        {
            get { return empAge; }
            set { empAge = Age; }
        }


        public string Name
        {
            get { return empName; }
            set
            {
                if (value.Length > 15)
                    Console.WriteLine("this name is too long.");
                else
                    empName = value;
            }
        }
        public int ID
        {
            get { return empID; }
            set { empID = value; }
        }
        public float pay
        {
            get { return currPay; }
            set { currPay = value; }
        }

        //constructors
        public Employee() { }

        public Employee(string name, int id, float pay, int age)
        {
            empName = name;
            empID = id;
            currPay = pay;
            empAge = age;
        }

        //methods
        //the int parameter that this method takes will come from somewhere in the Main method
        //currpay is a private field
        public void GiveBonus(float amount)
        {
            currPay += amount;
        }
        public void DisplayStats()
        {
            Console.WriteLine("name: {0}", empName);
            Console.WriteLine("ID: {0}", empID);
            Console.WriteLine("pay: {0}", currPay);
            Console.WriteLine("age: {0}", empAge);
        }
    }

}

Main method here

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//Encapsulation using traditional accessors/mutators or get/set methods
//the role of a get method is to return to the caller the current value of the underlying state data
//a set method allows the caller ot change the current value of the state data

//you need to have a getter and a setter for every field that the class has

namespace EmployeeApp
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.WriteLine("fun with encapsulation");
            //Employee emp = new Employee("marvin", 456, 4000, 56);
            //emp.GiveBonus(3);
           // emp.DisplayStats();
           // emp.Name = "wilson";
           // emp.DisplayStats();

            Employee joe = new Employee();

            Console.WriteLine(joe.Age++);
        }
    }
}

Answer 1

In your Age property, you are not changing the empAge member to the value passed in. This is probably why you aren’t seeing any changes when you tried ++ multiple times.

public int Age 
{ 
    get { return empAge; } 
    set { empAge = Age;  } // this does not set the value!
} 

Use the value instead:

public int Age 
{ 
    get { return empAge;   } 
    set { empAge = value;  } // use the value passed in
} 

And as others have pointed out, you are using the postfix version of the ++ operator. The prefix version will increment the amount first before writing the property to the console.