How to "reverse" array when setting values to make getting/setting more convenient?

I'm using enums to make it easier to keep track of data. Because of this, I found it more convenient to access values using an array than accessing directly. Here's a sample of my class:

public class Data {
    // Values
    int age;
    int salary;
    int booksOwned;

    // Accessor
    int[] data { get { int[] values = {age, salary, booksOwned}; return values; }}

    // Constructor
    public Data(int x, int y, int z) { age = x; salary = y; booksOwned = z; }

    
}

I did the opposite before, using the array as the base and having get/sets with the value names (age { get { return data[0]}}), but ran into issues, as the values in the base object would be updated.

Anyway, this has been working fine to access data, but I'm having trouble when setting data with this method. If I try:

Data tempData = new Data(22, 40, 3);
tempData.data[0] = 23;

I (understandably) run into issues. Can I make a setter to access these values, or would I be better off just accessing the values directly?

edit to add context:
These values are just samples, but I need to be able to adjust these values easily. In the actual sample, I have 8 data types, and they are all adjusted in the same way. This is something along the lines of what I (would like to) use the enum for:

public bool Increase(Data data, DataTypeEnum dataTypeEnum) {
    if (data[(int)dataTypeEnum] < 100) {
        data[(int)dataTypeEnum]++;
        return true;
    } else {
        return false;
    }
}

then in another area:

int numberToAdd = 30;
while (numberToAdd > 0) {
     DataTypeEnum dataToAddTo = (DataTypeEnum)Random.Range(0,3);
     if (Increase(tempData, dataToAddTo)) numberToAdd--;
}

This is horrible design. OOP is about classes, not named or index data-elements. It's way easier to understand to write myPerson.Age or myPerson.Salary than myData[0], isn't it?

Furthermore every member can have it's own type. Imagine you'd need a further property like DateOfBirth instead of Age. Then you get a problem, as all your arrays elements are ints, while you need a DateTime.

You can even implement your own getter- and setter-functions for every member.

I'm using enums to make it easier to keep track of data. Because of this, I found it more convenient to access values using an array than accessing directly. Here's a sample of my class:

public class Data {
    // Values
    public int Age { get; set; }
    public int Salary { get; set; }
    public int BooksOwned {get; set; }
}

It seems that you want to re-invent deconstructor:

//TODO: you may want to have "readonly struct" instead of "class"
public class Data {
  // Values: let's user read but not modify them
  public int Age {get;}
  public int Salary {get;}
  public int BooksOwned {get;}

  // Deconstructor:
  // Instead of array we return values
  public void Deconstruct(out int age, out int salary, out int booksOwned) {
    age = this.Age;
    salary = this.Salary;
    booksOwned = this.BooksOwned;
  }

  // Constructor (let's use readable names instead of x, y, z)
  public Data(int age, int salary, int booksOwned) { 
    //TODO: Validate input here, e.g. age must not be negative etc.
    this.Age = age;
    this.Salary = salary;
    this.BooksOwned = booksOwned; 
  }
}

Usage

Data data = new Data(1, 2, 3);

...

// ignore age - note "_",
// but declare and return mySalary and myBooksOwned
// The syntax is similar to array, but it is a tuple
// which allows you to have different types for different variables
(_, int mySalary, int myBooksOwned) = data;

Console.Write($"Salary is {mySalary}, owned {myBooksOwned}");