Top C# Properties Interview Questions and Answers

In C#, properties are members of a class or struct that allow you to access and modify private fields in a controlled way. They serve as a bridge between the private data within a class and the outside world, enabling you to retrieve (get) or update (set) the value of a field safely

Properties are similar to methods but are accessed like fields. They consist of two parts

• Getters: Retrieve the value of a private field.
• Setters: Assign a value to a private field.

class Person
{
    private string name;
    public string Name   // Property
    {
        get { return name; }  // Getter
        set { name = value; }  // Setter
    }
}

In C#, there are several types of properties based on their functionality and usage. These include

• Auto-Implemented Properties
• Read-Only Properties
• Write-Only Properties
• Expression-Bodied Properties
• Indexers
• Static Properties
• Computed (Calculated) Properties
• Backing Fields (Manually Implemented Properties)
• Init-only Properties (introduced in C# 9)

Each type serves a specific purpose in controlling how data is accessed, modified, and stored within a class

Auto-implemented properties are properties in C# that automatically provide a private, anonymous backing field. You don't need to manually declare a field for them. These properties have no additional logic in their get and set methods. The compiler automatically provides a backing field to store the property value. Introduced in C# 3.0 for simplicity and readability.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

A read-only property in C# can only be read, not written to. It is typically used to expose a value that can only be assigned once (usually within a constructor). The set accessor is omitted to make it read-only.

public class Person
{
    private string name;
    public string Name
    {
        get { return name; }
    }
    public Person(string name)
    {
        this.name = name;
    }
}

A write-only property allows data to be assigned to it, but not accessed. This can be useful when you want to store some data without exposing it to external code for reading.

public class PasswordManager
{
    private string password;
    public string Password
    {
        set { password = value; }
    }
}

Expression-bodied properties provide a shorter, more concise syntax for properties with a single expression in either the get or set accessor. They are available starting from C# 6.

public class Circle
{
    public double Radius { get; set; }
    public double Area => Math.PI * Radius * Radius;
}

In this example, Area is an expression-bodied property that calculates the area of a circle based on its radius.

An indexer is a special type of property that allows objects of a class to be indexed like arrays. It provides a way to access an object's elements using the same syntax as array indexing.

public class BookShelf
{
    private string[] books = new string[5];
    public string this[int index]
    {
        get { return books[index]; }
        set { books[index] = value; }
    }
}

--------------------------------------------

BookShelf shelf = new BookShelf();
shelf[0] = "The Great Gatsby";
Console.WriteLine(shelf[0]);  // Output: The Great Gatsby

With C# 9, you can use init in properties to provide a way to set the value during object initialization but prevent it from being modified afterward. This is a read-only property after initialization.

public class Person
{
    public string Name { get; init; }
    public int Age { get; init; }
}

var person = new Person { Name = "John", Age = 30 };
// person.Name = "Jane"; // Error: Cannot modify after initialization

Static properties belong to the class itself, rather than to instances of the class. These properties are shared across all instances of the class.

public class Configuration
{
    public static string AppName { get; set; }
}

These properties are used when the value of the property depends on other values within the class and is computed rather than stored. Computed properties typically do not have a backing field.

public class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
    public double Area => Width * Height;  // Computed property
}

Sometimes, you need more control over the property’s getter and setter. In such cases, you use a private backing field to store the property value and manually implement the get and set accessors.

public class Employee
{
    private double salary;

    public double Salary
    {
        get { return salary; }
        set
        {
            if (value < 0)
                throw new ArgumentException("Salary cannot be negative");
            salary = value;
        }
    }
}

Here, the Salary property uses a backing field (salary) and validates the value in the setter.

A field is a variable that is directly part of a class or struct, while a property provides a mechanism to get or set the value of a field. Fields are generally private to protect direct access and properties are public to allow controlled access to the data.

In sort we can say

• A field is a variable that holds data directly.
• A property provides a controlled way to access the value of a field through get and set methods.

public class Employee
{
    private string name;  // Field
    public string Name   // Property
    {
        get { return name; }
        set { name = value; }
    }
}

The get accessor defines how to retrieve the value of a property, while the set accessor defines how to assign a value to a property. These accessors allow encapsulation, where you can control how the data is accessed or modified.

You can apply different access modifiers to the get and set accessors to control access.

public string Name { get; private set; }

Yes, properties can be virtual, abstract, or override in C#, just like methods. This allows you to define polymorphic behavior using inheritance.

An abstract property does not provide an implementation and must be overridden in derived classes. It can only be declared in an abstract class.

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

public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area => Math.PI * Radius * Radius;
}

A virtual property allows a derived class to override its behavior.

public class Animal
{
    public virtual string Sound
    {
        get { return "Some sound"; }
    }
}

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

An override property replaces the base class's virtual or abstract property implementation in a derived class.

See Dog and Circle classes above.

public static int InstanceCount { get; set; }

Yes, both get and set accessors can include logic that throws exceptions, especially for validation purposes.

Public class Persion
{
 private int _age;
 public int Age
 {
     get => _age;
     set
     {
         if (value < 0) throw new ArgumentOutOfRangeException();
         _age = value;
     }
 }
}

Yes, properties in C# can be overridden in derived classes if they are declared with the virtual or abstract keyword in the base class. A virtual property provides a default implementation that can be optionally overridden using the override keyword. An abstract property, on the other hand, does not have an implementation and must be overridden in any non-abstract derived class. Properties marked as override in a derived class replace the base implementation.

Note: static properties cannot be overridden.

using System;

public abstract class BaseClass
{
    // Abstract property (must be overridden in derived classes)
    public abstract string AbstractProperty { get; }
    // Virtual property (can be optionally overridden)
    public virtual string VirtualProperty => "Base class virtual value";
    // Non-virtual property (cannot be overridden)
    public string NonVirtualProperty => "Base class non-virtual value";
    // Static property (can be hidden but not overridden)
    public static string StaticProperty => "Base class static value";
}

public class DerivedClass : BaseClass
{
    // Overriding the abstract property in DerivedClass
    public override string AbstractProperty => "Derived class abstract value";
    // Overriding the virtual property in DerivedClass
    public override string VirtualProperty => "Derived class virtual value";
    // Using 'new' keyword to hide the non-virtual property from the base class
    public new string NonVirtualProperty => "Derived class non-virtual value";
    // Hiding the static property (it won't be overridden, just hidden)
    public new static string StaticProperty => "Derived class static value";
}

public class Program
{
    public static void Main()
    {
        // Demonstrating Abstract Property
        BaseClass obj1 = new DerivedClass();
        Console.WriteLine($"Abstract Property: {obj1.AbstractProperty}");  // Output: Derived class abstract value
        // Demonstrating Virtual and Override Property
        Console.WriteLine($"Virtual Property: {obj1.VirtualProperty}");  // Output: Derived class virtual value
        // Demonstrating Non-Virtual Property (Hidden)
        Console.WriteLine($"Non-Virtual Property (Base): {obj1.NonVirtualProperty}");  // Output: Base class non-virtual value
        Console.WriteLine($"Non-Virtual Property (Derived): {(new DerivedClass()).NonVirtualProperty}");  // Output: Derived class non-virtual value

        // Demonstrating Static Property (Hidden, not overridden)
        Console.WriteLine($"Static Property (Base): {BaseClass.StaticProperty}");  // Output: Base class static value
        Console.WriteLine($"Static Property (Derived): {DerivedClass.StaticProperty}");  // Output: Derived class static value
    }
}

Abstract Property: Derived class abstract value
Virtual Property: Derived class virtual value
Non-Virtual Property (Base): Base class non-virtual value
Non-Virtual Property (Derived): Derived class non-virtual value
Static Property (Base): Base class static value
Static Property (Derived): Derived class static value

Yes, properties can be used in interfaces in C#. However, interfaces only define the signature of the property (i.e., the get and/or set methods), and the implementation of the property is provided by the class or struct that implements the interface.

• Auto-implemented properties don’t require explicit backing fields. The compiler handles it.
• Manually implemented properties use a private field that you manage yourself.

A property is shadowed when a derived class defines a new property with the same name as one in its base class using the new keyword.

public new string Name { get; set; }

Shadowing hides the base class member without overriding it.