Understanding Properties in C#

Document

In a C# application, a Property might look like a simple variable for storing and retrieving values. However, a property is fundamentally different from a variable.

A property automatically generates a hidden field during the compilation phase, which is then accessed through getter and setter methods. Although a property appears to store data, it actually works by wrapping storage and retrieval within methods.

Example

public int Score { get; private set; }

At first glance, it looks like there is a simple variable named Score. But during compilation, it transforms into: 

[CompilerGenerated]
private int <Score>k__BackingField;

public int Score
{
    [CompilerGenerated]
    get { return this.<Score>k__BackingField; }

    [CompilerGenerated]
    private set { this.<Score>k__BackingField = value; }
}
  • <Score>k__BackingField is the hidden field automatically created by the compiler for the Score property.
  • This field is protected so that users cannot directly access or modify it.

Thus, in C#, a property is a combination of a hidden field and get/set methods.

Why Use Properties?

  • To prevent direct external modification of variables.
  • To easily insert additional logic when getting or setting values.
  • To improve code consistency and data protection.

For these reasons, C# separates fields (variables) and properties.

Types of Properties : Auto-Implemented and Manual

When writing a property in C#, there are two approaches:
  • Auto-implemented properties
  • Manually implemented properties

Auto-Implemented Property

Auto-implemented properties don't require the developer to explicitly declare a variable. Simply defining the property is enough; the compiler creates a hidden backing field automatically. 

public int Score { get; private set; }

With just this declaration, the compiler generates the hidden field, as well as the methods to store and retrieve the value. This keeps the code clean and concise, ideal for simple data storage without special processing.

Manual Property

A manual property requires the developer to explicitly declare a variable. 

private int _score;

public int Score
{
    get { return _score; }
    private set
    {
        if (value < 0)
            _score = 0;
        else
            _score = value;
    }
}

Here, instead of a hidden backing field, the manually declared variable _score is used. Additional logic, such as validation or value adjustment, can be freely added inside the set block.

Manual properties are suitable when data needs validation, correction, or any special handling during assignment.

Summary

  • Auto-implemented properties eliminate the need to declare variables manually and automatically create hidden fields.
  • Manual properties allow developers to declare their own variables and insert custom logic during value assignment or retrieval.
  • For simple data storage, auto-implemented properties are convenient. For complex data handling, manual properties are more appropriate.

Popular posts from this blog

Understanding Arrays as Reference Types in C#

Image
Arrays as Reference Types In programming, it's important to understand the behavior of arrays. In most programming languages including C#, arrays are treated as reference types. This article will explore what that means and how to use that knowledge effectively. Value Types vs Reference Types In C#, data types are categorized into two main types: Value types : Store actual values directly. Examples : int , float , bool , struct Reference types : Store memory addresses instead of the actual values. Examples: class , string , array , delegate Arrays, like classes, are reference types. When you assign one array variable to another, you're copying the reference, not the actual data. Example: Arrays as Reference Types using System; class Program { static void Main() { int[] array1 = { 1, 2, 3 }; int[] array2 = array1; // Copy reference array2[0] = 100; Console.WriteLine(array1[0]); // Out...
Read more

Setting Up a Basic Follow Camera with Cinemachine 3.x

Image
Setting Up a Basic Follow Camera with Cinemachine 3.x Cinemachine has been significantly upgraded in version 3.x, introducing new concepts, improved terminology, and a refined workflow. In this post, we’ll go through how to set up a simple follow camera using the latest version. For more advanced examples, be sure to check out the sample scenes provided in the Cinemachine package—they’re very helpful for understanding the system. Install the Cinemachine Package Start by downloading and importing the Cinemachine package from the Unity Package Manager. Check the Main Camera After installation, you'll notice that the Main Camera now has a Cinemachine Brain component attached. Make sure the Live Camera field shows the name of your Cinemachine Camera. Create a Cinemachine Camera In the Hierarchy window, right-click and go to Cinemachine > Cinemachine Camera to create a new virtual camera. Set the Tracking Targe...
Read more

Understanding and Using ? (nullable) in C#

Image
Understanding and Using ? (nullable) in C# In C#, ? is the symbol used to declare a variable as nullable, meaning it can hold a null value. ? (nullable) declaration string text1 = null; string? text2 = null; Both variables are null , but when you call text1.ToString() , a runtime null reference exception will occur. This happens because text1 is null , meaning it points to nothing. Trying to access .ToString() on a null variable results in an exception. To put it into words, asking someone who has no thoughts, "What should we have for lunch?" is similar. The person doesn't have any thoughts, so asking them anything at all would be an error. On the other hand, text2 has been declared with ? , which tells the compiler, "This variable might be null ." However, just informing the compiler doesn't automatically prevent exceptions. You still need to handle it explicitly. ?. (null-conditional operator) Thus, ? ...
Read more