Chapter 2.5: Object-Oriented Programming with C#: Understanding Properties, Indexers, and Operator Overloading in C#

 Introduction:

We have covered various aspects of Object-Oriented Programming with C# in our previous articles. In this article, we'll explore properties, indexers, and operator overloading, which are powerful tools for creating expressive and user-friendly classes in C#. In the next chapter, we'll move on to advanced C# concepts.

Properties:

Properties are a way to provide access to an object's data while encapsulating the underlying storage mechanism. They can be used to define validation rules or perform other actions when getting or setting a value. Properties are declared using the get and set accessors:

class Person
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value.Trim(); }
    }
}

You can also use auto-implemented properties with default get and set accessors:

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

Indexers:

Indexers allow objects to be indexed like arrays. They are useful for creating collection classes that can be accessed using the familiar array syntax. Indexers are declared using the this keyword and square brackets:

class CustomList<T>
{
    private T[] data;

    public CustomList(int size)
    {
        data = new T[size];
    }

    public T this[int index]
    {
        get { return data[index]; }
        set { data[index] = value; }
    }
}

// Usage
CustomList<int> myList = new CustomList<int>(5);
myList[0] = 10;
Console.WriteLine(myList[0]);

Operator Overloading:

Operator overloading allows you to define custom behavior for standard operators when applied to your class objects. This can make your classes more expressive and easier to use. To overload an operator, use the operator keyword followed by the operator symbol:

class ComplexNumber
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

    public ComplexNumber(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b)
    {
        return new ComplexNumber(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }
}

// Usage
ComplexNumber a = new ComplexNumber(1, 2);
ComplexNumber b = new ComplexNumber(3, 4);
ComplexNumber c = a + b;

Conclusion:

In this article, we covered properties, indexers, and operator overloading in C#. These concepts are essential for creating expressive, user-friendly, and maintainable classes in C#. In the next chapter, we'll dive into advanced C# concepts to further enhance your understanding of the language. Stay tuned for more C# learning!