Bsrgvty

The statement

value -= foo(); // short for value = value - foo();

is equivalent to

var temp = value; // 0
var fooResult = foo(); // 1
value = temp - fooResult; // -1

That's why you are getting -1

Just look at the generated CIL:

.method private hidebysig static int32 foo() cil managed

 // Code size 19 (0x13)
 .maxstack 2
 .locals init ([0] int32 V_0)
 IL_0000: nop
 IL_0001: ldsfld int32 Program::'value'
 IL_0006: ldc.i4.7
 IL_0007: sub
 IL_0008: stsfld int32 Program::'value'
 IL_000d: ldc.i4.1
 IL_000e: stloc.0
 IL_000f: br.s IL_0011
 IL_0011: ldloc.0
 IL_0012: ret
 // end of method Program::foo

• 
  IL_0001: - Push the value of the static field on the stack. s:[value(0)]
  


• 
  IL_0006: - Push 7 onto the stack. s:[7, value(0)]
  


• 
  IL_0007: - Subtracts value2 (7) from value1 (0), returning a new value (-7).


• 
  IL_0008: - Replaces the value of the static field with val (value = -7).


• 
  IL_000d: - Push 1 onto the stack. s:[1, 7, value(-7)]
  


• 
  IL_000e: - Pop a value from stack into local variable 0. (lv = 1)
  


• 
  IL_0011: - Load local variable 0 onto stack. s:[lv(1), 7, value(-7)]
  


• 
  IL_0012: - Return (lv(1))
  

And the Main method:

.method private hidebysig static void Main(string[] args) cil managed

 .entrypoint
 // Code size 29 (0x1d)
 .maxstack 8
 IL_0000: nop
 IL_0001: ldsfld int32 Program::'value'
 IL_0006: call int32 Program::foo()
 IL_000b: sub
 IL_000c: stsfld int32 Program::'value'
 IL_0011: ldsfld int32 Program::'value'
 IL_0016: call void [mscorlib]System.Console::WriteLine(int32)
 IL_001b: nop
 IL_001c: ret
 // end of method Program::Main

• 
  IL_0001: - pushes value onto stack (which is 0)


• 
  IL_0006: - calls foo (which will return 1)


• 
  IL_000b: - subtract values: value2(1) from value1(0) (value(0) - value(1) = -1).

So the result is -1.

You can use menu Debug → Windows → Disassembly and check what goes on in the background:

I commented the most interesting parts.

 //static int value = 0;
 05750449 mov ebp,esp
 0575044B push edi
 0575044C push esi
 0575044D push ebx
 0575044E sub esp,2Ch
 05750451 xor edx,edx
 05750453 mov dword ptr [ebp-10h],edx
 05750456 mov dword ptr [ebp-1Ch],edx
 05750459 cmp dword ptr ds:[15E42D8h],0
 05750460 je 05750467
 05750462 call 55884370
 05750467 xor edx,edx
 05750469 mov dword ptr ds:[15E440Ch],edx // STEP_A place 0 in ds register
 somewhere
 0575046F nop
 05750470 lea esp,[ebp-0Ch]
 05750473 pop ebx
 05750474 pop esi
 05750475 pop edi
 05750476 pop ebp
 05750477 ret

 //value -= foo();
 057504AB mov eax,dword ptr ds:[015E440Ch] // STEP_B places (temp) to eax. eax now contains 0
 057504B0 mov dword ptr [ebp-40h],eax
 057504B3 call 05750038



 057504B8 mov dword ptr [ebp-44h],eax
 057504BB mov eax,dword ptr [ebp-40h]
 057504BE sub eax,dword ptr [ebp-44h] //STEP_C substract the return(-1) of call from the temp eax
 057504C1 mov dword ptr ds:[015E440Ch],eax // STEP_D moves eax (-1) value to our ds register to some memory location

 //Console.WriteLine(value);
 015E04C6 mov ecx,dword ptr ds:[015E440Ch] // Self explanatory; move our ds(-1) to ecx, and then print it out to the screen.
 015E04CC call 54CE8CBC

So it is true that when writing value -= foo(), it generates code something like this:

value = 0; // In the beginning STEP_A

//... main
var temp = value; //STEP_B
temp -= foo(); // STEP_C
value = temp; // STEP_D

I think it has something to do with how it subtracts value on the assembly level, and that causes some inconsistency in the program. I don't know if it has something to do with static or not. But from my intuition this is what happens:

Let's focus on value -= foo()

1. The old value get saved (pushed to the stack)


2. The foo() function returns 1
   


3. Now, the value is -7 due to foo() operation


4. HERE is the problem: The OLD value (which is the one that saved earlier, which is 0) subtracted with 1 and the result assigned to the current value.

value -= foo(); // value = value - foo();

foo() will return 1.

value is initially 0, so: 0 = 0 - 1.

Now the value has -1.

So the issue is with return 1.