C# Auto-Implemented Properties

In C#, auto-implemented properties provide a convenient way to define properties without explicitly declaring the backing field. They allow you to quickly define simple properties with a default implementation for getting and setting their values. The compiler automatically generates the backing field for you.

Here’s an example of how to use auto-implemented properties in C#:

public class Person
{
    // Auto-implemented properties
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

In the above example, the Person class has three auto-implemented properties: FirstName, LastName, and Age. The get and set accessors are automatically generated by the compiler, and the backing fields for these properties are hidden from you.

You can then use these properties as you would with any other properties:

Person person = new Person();
person.FirstName = "John";
person.LastName = "Doe";
person.Age = 30;

Console.WriteLine($"{person.FirstName} {person.LastName} is {person.Age} years old.");

Auto-implemented properties are useful when you have simple properties that don’t require additional logic or validation in their accessors. However, if you need to add custom logic to the property accessors, such as data validation or raising events, you should use regular properties with explicit backing fields.

It’s important to note that auto-implemented properties have limited functionality compared to regular properties, but they provide a concise syntax for defining properties with default behavior.

C# Auto-Implemented Properties Example:

Sure! Here’s an example that demonstrates the usage of auto-implemented properties in C#:

using System;

public class Rectangle
{
    public double Width { get; set; }   // Auto-implemented property
    public double Height { get; set; }  // Auto-implemented property

    public double Area
    {
        get { return Width * Height; }  // Computed property based on auto-implemented properties
    }
}

public class Program
{
    public static void Main()
    {
        Rectangle rectangle = new Rectangle();
        rectangle.Width = 5.0;
        rectangle.Height = 3.0;

        Console.WriteLine($"Width: {rectangle.Width}");
        Console.WriteLine($"Height: {rectangle.Height}");
        Console.WriteLine($"Area: {rectangle.Area}");
    }
}

In the above example, we have a Rectangle class with two auto-implemented properties: Width and Height. These properties allow us to get and set the width and height of a rectangle object.

The Area property is a computed property that calculates the area of the rectangle based on the values of the Width and Height properties. Since it doesn’t have a setter, it can only be read.

In the Main method, we create an instance of the Rectangle class and set the Width and Height properties to specific values. Then, we display the values of the properties as well as the computed area using the Console.WriteLine method.

When you run the program, the output will be:

Width: 5
Height: 3
Area: 15

This example showcases how you can use auto-implemented properties to encapsulate data and calculate derived values within a class.