Why Are Mutable Structs Considered 'Evil' in C#?

variable structure in C#: Why is it considered "evil"?

The structure in C#is a value type, which means that they will be copied when they are assigned. This will bring challenges when processing variable structures.

The variable structure allows to modify its data after creation. However, because they are copied by value, modifying the copy will not affect the original structure or other existing copies. This behavior may lead to unexpected results, especially in multi -threaded environments.

For example, suppose you have a variable structure that indicates the coordinates:

If you assign a variable to this structure and try to modify its X attribute:

<code class="language-csharp">public struct Coordinate
{
    public int X;
    public int Y;
}</code>

The change only affects the local copy stored in the Coordinate variable, not the original structure or any other reference to it. This can easily lead to inconsistent data and produce unpredictable behaviors in multi -threaded applications.

<code class="language-csharp">Coordinate coordinate = new Coordinate { X = 0, Y = 0 };
coordinate.X = 1;</code>

Therefore, it is generally recommended to avoid using variable structures. Instead, select the unable structure, where the data cannot be modified after creation. This ensures predictable behavior and eliminates potential accidental data damage in the value -type scenario.

The above is the detailed content of Why Are Mutable Structs Considered 'Evil' in C#?. For more information, please follow other related articles on the PHP Chinese website!