Property in C# is a member of a class that allows classes to read, write, and expose private fields while keeping the implementation details hidden.
In this post, we will try to understand how to use properties in C# with multiple examples.

Table of Contents
Explain properties in C#
C# Properties are special methods that are used to assign and read the value from a private field by using set
and get
accessors. A get
accessor returns a property value, whereas a set
accessor assigns a new value.
- C# Properites don’t have a storage location, unlike fields. Instead, they have accessors to read, write, and compute the values.
- Properties offer another level of abstraction to expose the private fields as we can’t directly access the private fields outside the class scope.
( get : Retrieve the value set : Assign the value)Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â

Syntax
The following is the syntax to define a property in C#.
<Access Modifier> <Return Type> <Property Name>
{
get {
// get accessor
// return value
}
set {
// set accessor
// assign a new value
}
}
Properties in C# example
The following example shows how to create a property in C#.
using System;
namespace PropertyDemo
{
class Employee
{
// private field
private string name;
// public property to access the private field
public string Name
{
get {
return name;
}
set {
name = value;
}
}
// Constructor
public Employee(string name)
{
this.name = name;
}
}
public class Programs
{
public static void Main(string[] args)
{
Employee employee = new Employee("Shekh Ali"); // Constructor
string name = employee.Name; // Calling the get block of Name property
Console.WriteLine($"Name : {name}");
employee.Name = "Mark Adams"; // Calling set block to assign the new value.
Console.WriteLine($"Name : {employee.Name}");
Console.ReadLine();
}
}
}
In the above example, the private name
 field is exposed via public property. Here, the get
and set
accessor of the Name
property is used to read and assign the value to the private name field of the Employee class.
The get and set accessor are not only limited to reading or writing the value to the property, but also allow us to perform complex calculations or business logic within the set or get blocks.
Example
Let’s create a property with a get and set accessor.
public string Name
{
get {
if (string.IsNullOrEmpty(name))
{
// Business Logic
name = "Name is not available !";
}
return name;
}
set {
name = value;
}
}
What are the types of properties in c#?
Following is the list of different types of properties in C#.
C# Properties Types | Description |
---|---|
01. Read-Write Property | It contains both get and set accessor |
02. Read-Only Property | It contains get accessor only |
03. Write-Only Property | It contains a set accessor only |
04. Auto implemented Property | It contains both get and set accessors without having logic inside the block. |
C# readonly property
The property that has only the get
accessor and no set
accessor is called readonly
property.
A readonly property allows you to only read the value of a private field. The readonly modifier specifies that the member is not allowed to modify. When you try to set the value of the readonly field/property, a compilation error occurs.
class Employee
{
private string name;
// ReadOnly Property
public string Name
{
get {
return name;
}
}
// Constructor
public Employee(string name)
{
this.name = name;
}
}
public class Programs
{
public static void Main(string[] args)
{
Employee employee = new Employee("Shekh Ali"); // Constructor
string name = employee.Name; // Calling get block of the ReadOnly property
Console.WriteLine($"Name : {name}");
employee.Name = "Mark Adams"; // Calling set block to assign the new value.
Console.WriteLine($"Name : {employee.Name}");
Console.ReadLine();
}
}

As we can see in the above example, It throws an error when we try to set the value to the property outside the constructor.
Write Only Properties in C#
The Write-Only property has only the set
block and not the get
block. It allows us to only set the values and not to read the value.
If we try to read the value, It will throw an error message.
private string name;
// Write Only Property
public string Name
{
set {
name =value;
}
}

Auto Implemented Properties in C#
In C#, An auto-implemented property contains both the get accessor and set accessor without having any business logic. It makes code more clean and readable and used when no additional business logic or calculation is needed in the get or set block.
The properties which do not require any code to be written inside the get method and set method of the class are known as Auto Implemented Properties in C#.
// Auto Implemented Property
public string Name { get; set; }
In the case of auto-implemented properties, the compiler internally creates private fields that can only be accessed through the property’s getter or setter.

Static Properties in C#
In C#, A property that is created using the static
keyword is known as a static property.
A static property can access directly by the class name without creating an instance of that class because the static property belongs to the class rather than the object of the class.
A static property will only allow you to use the static variables inside the getter and setter block.
using System;
namespace PropertyDemo
{
public class Employee
{
// Static field
private static string name;
// Static Property
public static string Name
{
get
{
return name;
}
set
{
name = value;
}
}
}
public class Programs
{
public static void Main(string[] args)
{
// Accessing static property by the class name.
Employee.Name = "Shekh Ali"; // Set Value
Console.WriteLine($"Name : {Employee.Name}"); // Get Value
}
}
}
C# properties vs fields
In C#, a field is a variable of any type that is declared directly in the class, whereas a property is a member that provides a flexible mechanism to read, write, or compute the value of a private field.
01. Field : A field is a variable that can be declared directly in a class or struct. A field should nearly always be private members of a class and can be accessed via public get and set properties. Fields are used for data hiding, which is a best practice for Object-Oriented design.
02. Properties : A property in C# is a member of the class that provides a flexible way to read, write or compute the data of a private field. Properties provide a level of abstraction so that we can change the value of the field while not affecting how they are used by a class.
We can encapsulate the business logic in properties, and adding an extra level of validation in the get and set accessor is acceptable but not always recommended.
Conclusion
This article has provided us with the following insights:
- Use of the properties and its Syntax.
- About the write-only and
readonly
property in C# - Use of static property
- Use of Auto implemented properties in C#
I hope you enjoyed and found this post useful. If you have any questions or comments, please leave them below.
References: MSDN- Properties in C#
Recommanded Articles:
- 10 Difference between interface and abstract class In C#
- C# Dynamic Type: Var vs dynamic keywords in C#
- C# 10 New features with examples | What’s new in C# 10?
- C# Array vs List
- C# Monitor class in multithreading with examples
- Exception Handling in C#| Use of try, catch, and finally block
- C# Enum | How To Play With Enum in C#?
- C# extension methods with examples
- Properties In C# with examples
- IEnumerable Interface in C# with examples
- Constructors in C# with Examples
- Top 10 Differences between Stored Procedure and Function in SQL Server
- Understanding the SOLID Principle: Single Responsibility Principle in C# - June 7, 2023
- Difference between var and dynamic in C# - May 26, 2023
- Understanding the Chain of Responsibility Design Pattern in C# - May 11, 2023