C# - Computed Properties

Computed Properties in C#

In C#, properties are an essential part of encapsulation and data access within classes. Among various types of properties, computed properties stand out for their ability to calculate a value dynamically, based on other fields or properties. This document provides a comprehensive explanation of computed properties in C#, including their syntax, benefits, use cases, and practical examples.

What Are Computed Properties?

A computed property in C# is a property whose value is calculated dynamically when the get accessor is called. Unlike traditional properties that return a stored value from a field, computed properties perform operations or logic to determine the value at runtime.

Basic Example

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

    public double Area
    {
        get { return Width * Height; }
    }
}
    

In the above example, Area is a computed property because its value is calculated from the Width and Height properties rather than being stored directly.

Benefits of Computed Properties

• Encapsulation: They hide the implementation details from the user.
• No Redundant Storage: No need to store a value that can be derived from other values.
• Consistency: The computed value is always up-to-date with the latest state of dependent properties or fields.
• Readability: Improves code readability by abstracting complex calculations.

Common Use Cases

• Calculating totals, averages, or derived statistics.
• Generating formatted strings like full names or descriptions.
• Encapsulating conditional logic that determines a value.
• Derived business logic such as discount rates, taxes, or statuses.

Computed Property with Only a Get Accessor

Most computed properties only implement the get accessor since the value is determined dynamically.

Example: Full Name

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public string FullName
    {
        get { return $"{FirstName} {LastName}"; }
    }
}
    

This approach avoids duplicating name logic and ensures that FullName always reflects the current values of FirstName and LastName.

Computed Property with Conditional Logic

Computed properties can include control statements to calculate a value based on various conditions.

Example: Eligibility Check

public class Applicant
{
    public int Age { get; set; }
    public bool HasCriminalRecord { get; set; }

    public bool IsEligible
    {
        get
        {
            return Age >= 18 && !HasCriminalRecord;
        }
    }
}
    

Here, IsEligible checks for multiple conditions to determine the result dynamically.

Expression-Bodied Computed Properties

Starting from C# 6.0, you can simplify computed properties using the expression-bodied syntax.

Syntax

public string FullName => $"{FirstName} {LastName}";
    

This syntax is concise and ideal for simple one-line computed properties.

Example

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

    public double Circumference => 2 * Math.PI * Radius;
}
    

Expression-bodied syntax reduces boilerplate and enhances readability for simple calculations.

Computed Properties with Backing Fields

In some cases, a computed property might work in conjunction with backing fields, either for caching purposes or to include a set accessor.

Example: Temperature Conversion

public class Weather
{
    private double _celsius;

    public double Celsius
    {
        get { return _celsius; }
        set { _celsius = value; }
    }

    public double Fahrenheit
    {
        get { return (_celsius * 9 / 5) + 32; }
    }
}
    

This demonstrates a one-way conversion from Celsius to Fahrenheit using a computed property.

Computed Properties with Private Setters

Although most computed properties are read-only, you can also use computed logic in the set accessor.

Example: Setting Age Based on Date of Birth

public class Person
{
    public DateTime DateOfBirth { get; set; }

    public int Age
    {
        get
        {
            var today = DateTime.Today;
            int age = today.Year - DateOfBirth.Year;
            if (DateOfBirth.Date > today.AddYears(-age)) age--;
            return age;
        }
    }
}
    

The Age is always computed based on DateOfBirth and the current date.

Caching in Computed Properties

In performance-sensitive applications, recomputing the same value can be expensive. In such cases, caching the computed value can be useful.

Example: Lazy Evaluation with Backing Field

public class Report
{
    private List _data;
    private double? _average;

    public Report(List data)
    {
        _data = data;
    }

    public double Average
    {
        get
        {
            if (_average == null)
            {
                _average = _data.Average();
            }
            return _average.Value;
        }
    }
}
    

Here, the average is computed only once and then cached for subsequent access.

Validation in Computed Properties

You can also embed validation logic in computed properties, especially useful when returning status indicators or derived metrics.

Example: Validation Property

public class FormInput
{
    public string Email { get; set; }

    public bool IsEmailValid
    {
        get { return Email != null && Email.Contains("@"); }
    }
}
    

This approach makes it easy to evaluate data validity as part of the property model.

Computed Properties in Structs

Computed properties are also supported in struct types, enhancing their utility in value types.

Example: Point Struct

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public double DistanceFromOrigin
    {
        get { return Math.Sqrt(X * X + Y * Y); }
    }
}
    

Here, DistanceFromOrigin is a computed property that calculates the Euclidean distance.

Limitations and Considerations

• Performance: Avoid heavy computations in frequently accessed computed properties unless cached.
• Side Effects: Properties should avoid side effects. Keep logic pure and deterministic.
• Debugging: Breakpoints inside get accessors can help troubleshoot logic but may be triggered often.
• Thread Safety: Ensure thread-safe access if the computed property involves shared data.

Comparison: Computed Property vs Method

Best Practices

• Use computed properties for values that are always derived from other data.
• Keep the logic simple and avoid side effects.
• Use expression-bodied syntax for concise definitions.
• Avoid long-running computations inside properties; consider caching or using methods instead.
• Document non-obvious logic in computed properties for maintainability.

Real-World Example: Invoice Total

public class Invoice
{
    public List Items { get; set; }

    public double TotalAmount
    {
        get { return Items.Sum(i => i.Price * i.Quantity); }
    }
}

public class Item
{
    public string Name { get; set; }
    public double Price { get; set; }
    public int Quantity { get; set; }
}
    

This practical example shows how computed properties can simplify business logic and increase clarity.

Computed properties are a powerful feature of C# that enhances encapsulation, improves code readability, and reduces redundancy. By calculating values on-the-fly based on other properties or fields, they keep the data model consistent and clean. Used effectively, computed properties make code more intuitive and maintainable. Whether you are building models, views, or data processing components, understanding and leveraging computed properties will help you write better C# applications.