Before I started using auto-implemented properties, I was taught that when assigning properties in the constructor (because of the potential of making a property read only), I should assign directly to the private member for the property (which we would usually name with the property's name with an underscore in front of it. EX: _propertyName.)

When I switched to using auto-implemented properties, I kept the practice, even so much as establishing that only the private members should be referenced inside the property's class. I understand those auto-implemented private members are referred to as "Backing Fields".

Considering the usefulness of the backing fields, I find it fascinating that they are invisible to intellisense until fully typed. Further, I made the observation that when you auto-implement the property, it appears as though you can assign to a Read Only property within the property's class.

Considering the changes that have happened in the .net framework, I am beginning to question what is the "Right" way to handle property's from within the class. I understand that is somewhat subjective, but I wonder are there drawbacks to the way I have done this? So I'm left with a couple questions on how this works, and what the implications on my software's design (however minor) are:

1. Does calling the auto-implemented property from within property's class call the Get and Set?
2. Does calling the property's backing field bypass this?
3. Am I wasting (however few) processor cycles by using the the property instead of the backing field?
4. Or am I exposing myself to a potential problem in the future by using the backing fields?

Or simply put:

What is difference between assigning to auto-Implemented properties VS assigning directly to their backing fields?

It seems this question almost straddles Software Engineering and Stack Overflow depending on how you word it. Please let me know if I should modify the wording or migrate it.

Thanks!