C# Properties

Last modified on: October 19, 2024

<h3>C# Properties: A Comprehensive Guide</h3>
<p>Properties in C# are a way to encapsulate data members of a class and provide controlled access to them. They allow you to read, write, or compute the values of private fields while providing a clear interface for the outside world. Properties are a fundamental aspect of object-oriented programming in C#, enhancing encapsulation and data protection.</p>
<hr />
<h3>1. <strong>What are Properties?</strong></h3>
<p>Properties act as intermediaries between the private fields of a class and the outside world. They can include logic for getting and setting the value of a field, providing a way to enforce rules or constraints on the data.</p>
<h4>Basic Syntax</h4>
<pre class="language-csharp"><code>public class ClassName
{
    private int _field; // Backing field

public int PropertyName
    {
        get { return _field; }
        set { _field = value; }
    }
}
</code></pre>
<hr />
<h3>2. <strong>Auto-Implemented Properties</strong></h3>
<p>C# provides a shorthand way to define properties known as auto-implemented properties. With auto-implemented properties, you don&rsquo;t need to define a backing field explicitly; the compiler handles it for you.</p>
<h4>Example: Auto-Implemented Properties</h4>
<pre class="language-csharp"><code>public class Car
{
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }
}

// Creating an object using auto-implemented properties
Car myCar = new Car
{
    Make = "Tesla",
    Model = "Model 3",
    Year = 2022
};

Console.WriteLine($"Car: {myCar.Year} {myCar.Make} {myCar.Model}"); // Output: Car: 2022 Tesla Model 3
</code></pre>
<p>In this example, <code>Make</code>, <code>Model</code>, and <code>Year</code> are defined as auto-implemented properties, simplifying the code.</p>
<hr />
<h3>3. <strong>Read-Only Properties</strong></h3>
<p>You can create read-only properties by providing only a <code>get</code> accessor. This means the property can be read, but not modified from outside the class.</p>
<h4>Example: Read-Only Properties</h4>
<pre class="language-csharp"><code>public class Car
{
    private string make;
    private string model;

public Car(string make, string model)
    {
        this.make = make;
        this.model = model;
    }

public string Make =&gt; make; // Read-only property
    public string Model =&gt; model; // Read-only property
}

// Creating an object and accessing read-only properties
Car myCar = new Car("Audi", "A4");
Console.WriteLine($"Car: {myCar.Make} {myCar.Model}"); // Output: Car: Audi A4
</code></pre>
<p>In this example, the properties <code>Make</code> and <code>Model</code> are read-only, meaning they can be set only through the constructor.</p>
<hr />
<h3>4. <strong>Write-Only Properties</strong></h3>
<p>Similarly, you can create write-only properties by providing only a <code>set</code> accessor. This means the property can be modified but not read.</p>
<h4>Example: Write-Only Properties</h4>
<pre class="language-csharp"><code>public class Car
{
    private string owner;

public string Owner
    {
        set { owner = value; } // Write-only property
    }
}

// Creating an object and setting the write-only property
Car myCar = new Car();
myCar.Owner = "John Doe"; // Setting owner
// Console.WriteLine(myCar.Owner); // This would result in an error
</code></pre>
<p>In this example, <code>Owner</code> is a write-only property, allowing you to set the value but not retrieve it.</p>
<hr />
<h3>5. <strong>Computed Properties</strong></h3>
<p>Properties can also be computed or derived from other fields. This allows you to define a property that calculates its value based on other data.</p>
<h4>Example: Computed Properties</h4>
<pre class="language-csharp"><code>public class Circle
{
    private double radius;

public Circle(double radius)
    {
        this.radius = radius;
    }

public double Radius
    {
        get { return radius; }
        set { radius = value; }
    }

public double Area // Computed property
    {
        get { return Math.PI * radius * radius; }
    }
}

// Creating an object and accessing the computed property
Circle myCircle = new Circle(5);
Console.WriteLine($"Circle Area: {myCircle.Area}"); // Output: Circle Area: 78.53981633974483
</code></pre>
<p>In this example, the <code>Area</code> property computes its value based on the <code>radius</code> field.</p>
<hr />
<h3>6. <strong>Property Validation</strong></h3>
<p>You can implement validation within the <code>set</code> accessor to ensure that only valid values are assigned to a property.</p>
<h4>Example: Property Validation</h4>
<pre class="language-csharp"><code>public class Car
{
    private int year;

public int Year
    {
        get { return year; }
        set
        {
            if (value &lt; 1886) // First car invented in 1886
            {
                throw new ArgumentOutOfRangeException(nameof(value), "Year must be 1886 or later.");
            }
            year = value;
        }
    }
}

// Creating an object and testing property validation
Car myCar = new Car();
try
{
    myCar.Year = 1800; // This will throw an exception
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine(ex.Message); // Output: Year must be 1886 or later.
}
</code></pre>
<p>In this example, the <code>set</code> accessor for the <code>Year</code> property includes validation to ensure the year is not earlier than 1886.</p>
<hr />
<h3>7. <strong>Using Properties with Interfaces</strong></h3>
<p>Properties can also be part of interfaces, allowing for a contract that classes must adhere to.</p>
<h4>Example: Properties in Interfaces</h4>
<pre class="language-csharp"><code>public interface IVehicle
{
    string Make { get; set; }
    string Model { get; set; }
    int Year { get; set; }
}

public class Car : IVehicle
{
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }
}

// Using properties defined in an interface
IVehicle myCar = new Car
{
    Make = "Ford",
    Model = "Mustang",
    Year = 2022
};

Console.WriteLine($"Car: {myCar.Year} {myCar.Make} {myCar.Model}"); // Output: Car: 2022 Ford Mustang
</code></pre>
<p>In this example, the <code>IVehicle</code> interface defines properties that must be implemented by any class that inherits from it.</p>
<hr />
<h3>Conclusion</h3>
<p>C# properties provide a powerful way to encapsulate data and control access to class members. They enhance readability and maintainability while allowing for data validation and computed values. Understanding how to effectively use properties will significantly improve your object-oriented programming skills in C#.</p>

Web Technology View More