How to use properties and indexers to simplify code in C#

How to use properties and indexers in C# to simplify code

In C#, properties and indexers are two powerful language features that can help us simplify the code and Improve code readability and flexibility. This article explains how to use properties and indexers to simplify your code, and provides some concrete code examples.

1. Attributes

Attributes are special members used to access and set class objects. Through attributes, we can encapsulate access to internal fields of a class and provide a more intuitive and safe way to access class data. Here is an example:

public class Person
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

In the above example, we have defined a property named Name to access and set the private field name. Through attributes, we can access and set the value of name in the following ways:

Person person = new Person();
person.Name = "Alice";
Console.WriteLine(person.Name);  // 输出：Alice

Through attributes, we can add additional logic in the process of getting and setting fields, such as input Values ​​are verified and processed. Here is an example:

public class Person
{
    private int age;
    
    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 0 && value <= 120)
                age = value;
            else
                throw new ArgumentOutOfRangeException("Age must be between 0 and 120.");
        }
    }
}

In the above example, we have validated the age field to ensure that the age is within the legal range. If the set value is out of range, an exception will be thrown.

2. Indexer

The indexer is a special property that allows us to access and set elements in an object in an array-like manner. Indexers allow us to provide array-like access to instances of a class, which is useful for working with data structures such as sets and lists. Here is an example:

public class Students
{
    private List<string> names;

    public Students()
    {
        names = new List<string>();
    }

    public string this[int index]
    {
        get
        {
            if (index >= 0 && index < names.Count)
                return names[index];
            else
                throw new IndexOutOfRangeException("Invalid index.");
        }
        set 
        {
            if (index >= 0 && index < names.Count)
                names[index] = value;
            else if (index == names.Count)
                names.Add(value);
            else
                throw new IndexOutOfRangeException("Invalid index.");
        }
    }
}

In the above example, we have defined a class named Students and defined an indexer for it. Through the indexer, we can access and set elements in the Students class through subscripts. For example:

Students students = new Students();
students[0] = "Alice";
students[1] = "Bob";
Console.WriteLine(students[0]);  // 输出：Alice
Console.WriteLine(students[1]);  // 输出：Bob

By using indexers, we can achieve array-like access, making the code more concise and easier to understand.

Summary:

Properties and indexers are important features in C# for simplifying code. By using properties, we can access and set the object's data more intuitively and safely. Indexers can help us access and set elements in an object in an array-like manner. By using attributes and indexers appropriately, we can make the code more concise and readable, while also improving the flexibility and maintainability of the code.

The above is the detailed content of How to use properties and indexers to simplify code in C#. For more information, please follow other related articles on the PHP Chinese website!