C# - 12 Properties

12 Properties in C#

Introduction to C# 12 Properties

C# 12 introduces several enhancements that improve the flexibility, readability, and maintainability of C# properties. Properties are one of the most important features in C# programming and object-oriented programming (OOP) because they allow controlled access to class data. With the evolution of the .NET 8 platform and modern C# language features, property handling has become more powerful than ever.

In this detailed guide, we will explore everything about C# 12 properties, including auto-implemented properties, required properties, init-only properties, expression-bodied properties, field-backed properties, property patterns, and more. These notes are designed for learners, developers preparing for interviews, and professionals building enterprise applications using C#.

1. What Are Properties in C#?

In C#, a property is a member of a class that provides a flexible mechanism to read, write, or compute the value of a private field. Properties are special methods called accessors — get and set.

Basic Property Syntax

public class Student
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

Here, the property Name controls access to the private field name. This ensures data encapsulation, which is a fundamental principle of OOP.

2. Auto-Implemented Properties in C# 12

Auto-implemented properties remove the need to explicitly declare a private backing field. This is one of the most widely used features in modern C# development.

public class Employee
{
    public string FirstName { get; set; }
    public int Age { get; set; }
}

The compiler automatically creates a hidden backing field. This makes the code cleaner and improves readability.

Benefits

• Less boilerplate code
• Improved maintainability
• Cleaner class definitions

3. Required Properties in C# 12

One of the most powerful features introduced in recent C# versions and enhanced in C# 12 is required properties. These ensure that certain properties must be initialized during object creation.

public class Product
{
    public required string Name { get; set; }
    public required decimal Price { get; set; }
}

When creating an object:

var product = new Product
{
    Name = "Laptop",
    Price = 75000
};

If you fail to initialize required properties, the compiler throws an error. This improves data consistency and reduces runtime bugs.

4. Init-Only Properties

Init-only properties allow setting a property only during object initialization. After that, the value becomes immutable.

public class Order
{
    public int OrderId { get; init; }
    public string CustomerName { get; init; }
}

This is extremely useful in building immutable objects and working with record types.

5. Expression-Bodied Properties

Expression-bodied members allow properties to be defined using lambda expressions. This reduces code length for computed properties.

public class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }

    public double Area => Width * Height;
}

This improves readability and aligns with modern C# syntax improvements.

6. Read-Only and Write-Only Properties

Read-Only Property

public class Person
{
    public string Country { get; } = "India";
}

Write-Only Property

private string password;

public string Password
{
    set { password = value; }
}

Write-only properties are rare but useful for security scenarios.

7. Backing Fields with Field Keyword (C# 12 Feature)

C# 12 enhances how developers can work with backing fields. You can now reference the implicit backing field using the field keyword inside property accessors.

public string Title
{
    get;
    set
    {
        field = value.Trim();
    }
}

This simplifies validation logic without explicitly declaring a separate private variable.

8. Property Patterns in C#

Property patterns allow pattern matching based on object properties.

public static string GetDiscount(Product product) =>
    product switch
    {
        { Price: > 50000 } => "High Discount",
        { Price: > 20000 } => "Medium Discount",
        _ => "No Discount"
    };

This improves decision-making logic and supports clean code architecture.

9. Static Properties

Static properties belong to the class instead of an instance.

public class Company
{
    public static string CompanyName { get; set; } = "Tech Solutions";
}

Accessed as:

Console.WriteLine(Company.CompanyName);

10. Virtual and Override Properties

Properties can participate in inheritance.

public class Animal
{
    public virtual string Sound { get; set; } = "Unknown";
}

public class Dog : Animal
{
    public override string Sound { get; set; } = "Bark";
}

This supports runtime polymorphism in C# object-oriented programming.

11. Abstract Properties

Abstract properties must be implemented in derived classes.

public abstract class Shape
{
    public abstract double Area { get; }
}

public class Circle : Shape
{
    public double Radius { get; set; }

    public override double Area => 3.14 * Radius * Radius;
}

12. Indexer Properties

Indexers allow instances of a class to be indexed like arrays.

public class SampleCollection
{
    private string[] data = new string[10];

    public string this[int index]
    {
        get { return data[index]; }
        set { data[index] = value; }
    }
}

Indexers enhance usability in collection-like classes.

Advantages of Modern C# Properties

• Improved encapsulation
• Better data validation
• Enhanced readability
• Reduced boilerplate code
• Stronger compile-time safety
• Better support for clean architecture

C# 12 Properties in Real-World Applications

Modern enterprise applications built using .NET 8 rely heavily on properties for:

• Entity Framework Core models
• ASP.NET Core Web APIs
• Data Transfer Objects (DTOs)
• Record types
• Immutable configurations

Understanding C# 12 property features is essential for building scalable and maintainable applications.

C# 12 properties bring powerful enhancements that make object modeling cleaner, safer, and more expressive. From required properties and init-only setters to field-backed validation and property patterns, modern C# empowers developers to write robust and maintainable code.

Mastering C# 12 properties is crucial for anyone serious about C# programming, .NET 8 development, and software engineering best practices.