Properties Interview Questions C#.NET

Properties Interview Questions and Answers C#.NET

In this article, I am going to discuss most frequently asked Properties Interview Questions and Answers on C#.NET.

What are Properties in C#? Explain with an example?

Properties in C# are class members that provide a flexible mechanism to read, write, or compute the values of private fields. Properties can be used as if they are public data members, but they are actually special methods called accessors. This enables data to be accessed easily and still helps promote the safety and flexibility of methods.

In the example below _firstName and _lastName are private string variables which are accessible only inside the Customer class. _firstName and _lastName are exposed using FirstName and LastName public properties respectively. The get property accessor is used to return the property value, and a set accessor is used to assign a new value. These accessors can have different access levels. The value keyword is used to define the value being assigned by the set accessor. The FullName property computes the full name of the customer. Full Name property is read-only because it has only the get accessor. Properties that do not implement a set accessor are read-only.

The code block for the get accessor is executed when the property is read and the code block for the set accessor is executed when the property is assigned a new value.

class Customer
{
    // Private fileds not accessible outside the class.
    private string _firstName = string.Empty;
    private string _lastName = string.Empty;
    private string _coutry = string.Empty;

    // public FirstName property exposes _firstName variable
    public string FirstName
    {
        get
        {
            return _firstName;
        }
        set
        {
            _firstName = value;
        }
    }
    // public LastName property exposes _lastName variable
    public string LastName
    {
        get
        {
            return _lastName;
        }
        set
        {
            _lastName = value;
        }
    }
    // FullName property is readonly and computes customer full name.
    public string FullName
    {
        get
        {
            return _lastName + ", " + _firstName;
        }
    }
    //Country Property is Write Only
    public string Country
    {
        set
        {
            _coutry = value;
        }
    }

}
class MainClass
{
    public static void Main()
    {
        Customer CustomerObject = new Customer();
        //This line will call the set accessor of FirstName Property
        CustomerObject.FirstName = "David";
        //This line will call the set accessor of LastName Property
        CustomerObject.LastName = "Boon";
        //This line will call the get accessor of FullName Property
        Console.WriteLine("Customer Full Name is : " + CustomerObject.FullName);
    }
}
Explain the 3 types of properties in C# with an example? 

Read Only Properties:

Properties without a set accessor are considered read-only. In the above example, FullName is a read-only property.

Write Only Properties:

Properties without a get accessor are considered write-only. In the above example, Country is a write-only property.

Read Write Properties:

Properties with both a get and set accessor are considered read-write properties. In the above example, FirstName and LastName are read-write properties.

What are the advantages of properties in C#?
  1. The Properties can validate data before allowing a change.
  2. Properties can transparently expose data on a class where that data is actually retrieved from some other source such as a database.
  3. The Properties can take an action when data is changed, such as raising an event or changing the value of other fields.
What is a static property? Give an example? 

A property that is marked with a static keyword is considered as a static property. This makes the property available to callers at any time, even if no instance of the class exists. In the example below PI is a static property.

class Circle
{
    private static double _pi = 3.14;
    public static double PI
    {
        get
        {
            return _pi;
        }
    }
}
class MainClass
{
    public static void Main()
    {
        Console.WriteLine(Circle.PI);
    }
}
What is a virtual property? Give an example? 

A property that is marked with virtual keyword is considered virtual property. Virtual properties enable derived classes to override the property behavior by using the override keyword. In the example below FullName is virtual property in the Customer class. BankCustomer class inherits from Customer class and overrides the FullName virtual property. In the output you can see the over riden implementation. A property overriding a virtual property can also be sealed, specifying that for derived classes it is no longer virtual.

class Customer
{
    private string _firstName = string.Empty;
    private string _lastName = string.Empty;

    public string FirstName
    {
        get
        {
            return _firstName;
        }
        set
        {
            _firstName = value;
        }
    }
    public string LastName
    {
        get
        {
            return _lastName;
        }
        set
        {
            _lastName = value;
        }
    }
    // FullName is virtual
    public virtual string FullName
    {
        get
        {
            return _lastName + ", " + _firstName;
        }
    }
}
class BankCustomer : Customer
{
    // Overriding the FullName virtual property derived from customer class
    public override string FullName
    {
        get
        {
            return "Mr. " + FirstName + " " + LastName;
        }
    }
}
class MainClass
{
    public static void Main()
    {
        BankCustomer BankCustomerObject = new BankCustomer();
        BankCustomerObject.FirstName = "David";
        BankCustomerObject.LastName = "Boon";
        Console.WriteLine("Customer Full Name is : " + BankCustomerObject.FullName);
    }
}
What is an abstract property? Give an example?

A property that is marked with abstract keyword is considered abstract property. An abstract property should not have any implementation in the class. The derived classes must write their own implementation. In the example below FullName property is abstract in the Customer class. BankCustomer class overrides the inherited abstract FullName property with its own implementation.

using System;
abstract class Customer
{
    private string _firstName = string.Empty;
    private string _lastName = string.Empty;

    public string FirstName
    {
        get
        {
            return _firstName;
        }
        set
        {
            _firstName = value;
        }
    }
    public string LastName
    {
        get
        {
            return _lastName;
        }
        set
        {
            _lastName = value;
        }
    }
    // FullName is abstract
    public abstract string FullName
    {
        get;
    }
}
class BankCustomer : Customer
{
    // Overriding the FullName abstract property derived from customer class
    public override string FullName
    {
        get
        {
            return "Mr. " + FirstName + " " + LastName;
        }
    }
}
class MainClass
{
    public static void Main()
    {
        BankCustomer BankCustomerObject = new BankCustomer();
        BankCustomerObject.FirstName = "David";
        BankCustomerObject.LastName = "Boon";
        Console.WriteLine("Customer Full Name is : " + BankCustomerObject.FullName);
    }
}

Can you use virtual, override or abstract keywords on an accessor of a static property? 
No, it is a compile-time error to use a virtual, abstract or override keywords on an accessor of a static property.

SUMMARY

In this article, I try to explain most frequently asked Properties Interview Questions and Answers on C#.NET. I hope this article will help you with your need. I would like to have your feedback. Please post your feedback, question, or comments about this article.

Follow Us

Leave a Reply

Your email address will not be published. Required fields are marked *