Perhaps if we write out a method to do the equivalent of what x++ does it will make this clearer.

```
public static int PostIncrement(ref int x)
{
int valueBeforeIncrement = x;
x = valueBeforeIncrement + 1;
return valueBeforeIncrement;
}
Right? Increment the value passed and return the original value: that's the definition of the postincrement operator.
Now, let's see how this behavior plays out in your example code:
int x = 0;
x = PostIncrement(ref x);
PostIncrement(ref x) does what? Increments x, yes. And then [b]returns what x was before the increment[/b]. This return value then gets assigned to x.
So the order of values assigned to x is 0, then 1, then 0.
This might be clearer still if we re-write the above:
```

int x = 0; // x is 0.

int temp = PostIncrement(ref x); // Now x is 1, and temp is 0.

x = temp; // Now x is 0 again.

```
Your fixation on the fact that when you replace x on the left side of the above assignment with y, "you can see that it first increments x, and later attributes it to y" strikes me as confused. It is not x that is being assigned to y; it is [b]the value formerly assigned to x[/b]. Really, injecting y makes things no different from the scenario above; we've simply got:
```

int x = 0; // x is 0.

int y = 0; // y is 0.

int temp = PostIncrement(ref x); // Now x is 1, and temp is 0.

y = temp; // y is still 0.

`So it's clear: x = x++ effectively does not change the value of x. It always causes x to have the values x0, then x0 + 1, and then x0 again.`