Is there a better way to express this

[zms9110750]

public struct Fight
	{
		public float hp;
		public float maxHp;
		public float atk;
		public float def;
		public float shield;
		public int level;
		public float gold;
		public float exp;

		public static Fight operator +(Fight a, Fight b) => new Fight()
		{
			hp = a.hp + b.hp,
			maxHp = a.maxHp + b.maxHp,
			atk = a.atk + b.atk,
			def = a.def + b.def,
			shield = a.shield + b.shield,
			level = a.level + b.level,
			gold = a.gold + b.gold,
			exp = a.exp + b.exp,
		};

		public static Fight operator -(Fight a, Fight b) => new Fight()
		{
			hp = a.hp - b.hp,
			maxHp = a.maxHp - b.maxHp,
			atk = a.atk - b.atk,
			def = a.def - b.def,
			shield = a.shield - b.shield,
			level = a.level - b.level,
			gold = a.gold - b.gold,
			exp = a.exp - b.exp,
		};
	}

It's too dangerous to hand write such code.
It's easy to make mistakes or miss.
Or when you add fields later, you may forget to change them.

One way I'm currently learning is to do these things by reflection.
But I heard that reflection consumes a lot of performance.

[HaloFour]

Is there a language question here? Writing code like that isn't unique to C# or these use cases, you do need to be careful. You mitigate the danger through many means, such as just having good unit tests. You could also use analyzers to detect when you've missed a field, or source generators to emit the operators for you. You could also use reflection and expression trees combined into a delegate, which would give you a performance hit up front but wouldn't be appreciably slower from that point on.

[qrli]

At 1st glance, it is questionable to:

• Use struct for such big object, unless you use an array as the pool of entities and modify in-place
• Use +/- over all properties together for a game entity
• Use operator to produce such big new entity objects for each operation

[zms9110750]

This is probably a flag game. I need to show the damage I received from fighting the enemy before fighting.
I now use the method of letting them fight once to judge the damage. However, it is necessary to restore the contents of both parties or copy a copy of the contents.
struct is easy to copy.

[theunrepentantgeek]

A heap based immutable data structure would be preferable as it would avoid the need to make copies of any unchanged information.

I remember reading a case study where a significant application (multiple megalines of code) was migrated from using mutable data structures that got defensively copied to using immutable ones with copy-on-write; the result was double the throughput with 30% less memory load.

Nonetheless, this thread is off-topic for this repo - we're discussing potential changes to the C# language itself.

I'd suggest maybe the CodeReview StackExchange, maybe the original StackOverflow or the C# Discord.

[huoyaoyuan]

If such pattern is common in your project, it's gonna worth to write a custom source generator.
There are patterns not used so widely, making them unsuitable to take a place in language design. Source generator can satisfy some desires.