How can I access the backing variable of an auto-implemented property?

In the past we declared properties like this:

public class MyClass
{
    private int _age;

    public int Age
    {
          get{ return _age;  }
          set{ _age = value; }
    }
}

Now we can do:

public class MyClass
{
    public int Age {get; set;} 
}

My question is, how can I access the private variable that is created automatically using this notation?

I would rather access the private variable and not the public accessor 'Age'. Is there a default notation to access the private variable, or it is just not possible?

Solution 1:

The aim of the new automatic properties is to reduce the amount of boilerplate code you need to write when you just have a simple property that doesn't need any special logic in the get or the set.

If you want to access the private member that these properties use, that's usually for a few reasons:

• You need to more than just a simple get/set - in this case, you should just avoid using automatic properties for this member.
• You want to avoid the performance hit of going through the get or set and just use the member directly - in this case, I'd be surprised if there really was a performance hit. The simple get/set members are very very easy to inline, and in my (admittedly limited) testing I haven't found a difference between using the automatic properties and accessing the member directly.

• You only want to have public read access (i.e. just a 'get') and the class write to the member directly - in this case, you can use a private set in your automatic property. i.e.

  public class MyClass
  {
      public int Age {get; private set;} 
  }

This usually covers most the reasons for wanting to directly get to the backing field used by the automatic properties.

Solution 2:

Your usage of automatic properties implies that you do not need any getting/setting logic for the property thus a private backing variable is unneccessary.

Don't use automatic properties if you have any complex logic in your class. Just go private int _age and normal getters/setters as you normally would.

IMO, automatic properties are more suited for quickly implementing throwaway objects or temporary data capsules like:

public class TempMessage {
    public int FromID { get; set; }
    public int ToID { get; set; }
    public string Message { get; set; }
}

Where you don't need much logic.

Solution 3:

This syntax is commonly called "syntax sugar", which means that the compiler takes that syntax and translates it into something else. In your example, the compiler would generate code that looks something like this:

[CompilerGenerated]
private int <Age>k_BackingField;

public int Age
{
   [CompilerGenerated]
   get
   {
      return this.<Age>k_BackingField;
   }
   [CompilerGenerated]
   set
   {
      this.<Age>k_BackingField = value;
   }

Even knowing all of that, you could probably access the backing field directly but that sort of defeats the purpose of using automatic properties. I say probably here because you then depend on an implementation detail that could change at any point in a future release of the C# compiler.

Solution 4:

Behind the scenes what happens is the injection of a private member variable, prefixed with <>k__AutomaticallyGeneratedPropertyField#

From C# 3.0 Automatic Properties explained

Although it may be possible to use that private member directly, it's very hacky and unnecessary.