Summing the values of two same-type structs

Question

So I have a struct like this:

public struct Attributes {
    public int vitality;
    public int intelligence;
    public int dexterity;
    public int agility;
}

And I use it like this:

Attributes a = new Attributes();
Attributes b = new Attributes();

And what I want to achieve is this:

Attributes c = new Attributes();
c = a + b;

I want this to give me the sum of these 4 variables I specified above of those two Attributess.

Inside the struct, I tried to have this:

public static Attributes operator +(Attributes x, Attributes y) {
        PropertyInfo[] info = typeof(Attributes).GetType().GetProperties();
        for (int i = 0; i < info.Length; i++) {                
            info[i].SetValue(x, (int) info[i].GetValue(x) + (int) info[i].GetValue(y), null);
        }

        return x;
}

This apparently doesn't work, giving me an error.

Can you guys help me about this? What could I do to achieve what I want? Thanks.

Answer 1

Just use the following:

public static Attributes operator +(Attributes x, Attributes y) {
        return new Attributes 
        {
            vitality = x.vitality + y.vitality,
            intelligence = x.intelligence + y.intelligence,
            dexterity = x.dexterity+ y.dexterity,
            agility = x.agility + y.agility
        };
}

If you don't have to, there's no need to be fancy and use reflection. It's a powerful tool but don't fall into the golden hammer fallacy. Only use it where truly necessary.

EDIT: if you really do want to use Reflection, this is a working version of your code:

public static Attributes operator +(Attributes x, Attributes y)
{
    FieldInfo[] info = typeof(Attributes).GetFields();
    object boxedResult = new Attributes();
    foreach (FieldInfo fi in info)
    {
        fi.SetValue(boxedResult, (int)fi.GetValue(x) + (int)fi.GetValue(y));
    }

    return (Attributes)boxedResult;
}

I think it warrants some explanation for what changes I made:

1. I would consider it unusual if operator+ modified one of its operands, so I made it return a new Attributes struct instead.
2. You called typeof(Attributes).GetType() which basically took the type of Attributes and got the type of the type, which is definitely not what you want.
3. You were checking for property info, but Attributes does not have properties, only fields.
4. I explicitly boxed the Attributes struct before setting its fields. Boxing a struct makes a copy of it, and boxing happens when you take a value type (like any struct for example) and cast it to object. What happens is your value type (which lives on the stack) is put into a neat little reference-type box and stored on the heap, since only reference types can live on the heap. Actually, a copy of it is stored on the heap. So since SetValue takes an object parameter as the "target", the struct would be boxed every time, effectively taking your changes and applying them to a copy which is then promptly thrown away. By explicitly boxing it, I make all the changes on the same copy of your struct, and then returning that after unboxing it. This step would not be necessary if Attributes was a reference type.