Не понимаю заранее поведение оператора декремента с типом Nullable

Question

Ok, это может быть очевидным для некоторых из вас, но я озадачен поведением я получаю от этого достаточно простого кода:

public static void Main(string[] args) 
{ 
    int? n = 1; 
    int i = 1; 
    n = ++n - --i; 
    Console.WriteLine("Without Nullable<int> n = {0}", n); //outputs n = 2 

    n = 1; 
    i = 1; 
    n = ++n - new Nullable<int>(--i); 
    Console.WriteLine("With Nullable<int> n = {0}", n); //outputs n = 3 
    Console.ReadKey(); 
} 

I exepcted оба выхода должны быть одинаковыми и равными 2, но, как ни странно, это не так. Может кто-нибудь объяснить, почему?

EDIT: Хотя код для создания этого «странного» поведения, по общему признанию надуманный, это выглядит как ошибка в C# компилятора, хотя, казалось бы, неважные и причина, кажется, встраиваемыми new, как James указывал на начальном этапе. Но поведение не ограничивается операциями. Вызовы метода ведут себя точно так же, т. Е. Их вызывают дважды, когда их нужно вызывать только один раз.

Рассмотрим следующий репро:

public static void Main() 
    { 
     int? n = 1; 
     int i = 1; 
     n = n - new Nullable<int>(sideEffect(ref i)); 
     Console.WriteLine("With Nullable<int> n = {0}", n); 
     Console.ReadKey(); 
    } 

    private static int sideEffect(ref int i) 
    { 
     Console.WriteLine("sideEffect({0}) called", i); 
     return --i; 
    } 

Конечно, выход есть 2, когда он должен быть 1 и "sideEffect(i) called" печатается дважды.

Answer 1

EDIT: Это было подтверждено как ошибка в компиляторе командой. Это зафиксировано в Рослине. В качестве обходного пути используйте бросок (int?)(--i), чтобы остановить появление ошибки или, в первую очередь, не сделать ее явно Nullable<int>.

Первый блок кода генерирует следующее в отражателе:

int? nullable3; 
int? nullable = 1; 
int num = 1; 
int? nullable2 = nullable; 
nullable2 = nullable = nullable2.HasValue 
    ? new int?(nullable2.GetValueOrDefault() + 1)  
    : ((int?) (nullable3 = null)); 
int num2 = --num; 
nullable = nullable2.HasValue 
    ? new int?(nullable2.GetValueOrDefault() - num2) 
    : ((int?) (nullable3 = null)); 
Console.WriteLine("Without Nullable<int> n = {0}", nullable); 

втором следующее:

nullable = 1; 
num = 1; 
nullable2 = nullable; 
nullable2 = nullable = nullable2.HasValue 
    ? new int?(nullable2.GetValueOrDefault() + 1) 
    : ((int?) (nullable3 = null)); 
num2 = --num; 
nullable = nullable2.HasValue 
    ? new int?(nullable2.GetValueOrDefault() - --num) 
    : null; 
Console.WriteLine("With Nullable<int> n = {0}", nullable); 

Они более или менее такой же, вплоть до присвоения nullable. Он запускает --num дважды, заставляя его запускать 2 - -1, в результате чего получилось 3.

Он также делает то же самое с выражениями, как i = ~i, но не с выражениями вызова метода ...

Answer 2

Это довольно интересная проблема, от того, что я могу видеть, компилятор появляется оценить заявления --/++ более чем один раз. Например, следующее:

n = ++n - new Nullable<int>(i++) 

приводит n становится 0 (который можно было бы ожидать), но i теперь 3 (который можно было бы ожидать, чтобы быть 2). Однако, если я

n = ++n - new Nullable<int>(i); 

Тогда я получить ожидаемый результат (n = 1 и i = 1)

Я могу только предположить, что это как-то связано с new Nullable вызова, находящегося в режиме реального времени. Я действительно не вижу в этом проблемы, поскольку это, вероятно, не будет считаться вашим повседневным кодом, однако, по-моему, это похоже на ошибку с компилятором.

Answer 3

Ну его наиболее странным, я пытался разыскать фактический код от «-», но я не могу, но если вы

  n = 1; 
     i = 1; 
     n = ++n - new Nullable<int>(i--); 
     Console.WriteLine("With Nullable<int> n = {0}", n); //outputs n = 2 
     Console.ReadKey(); 

Он выдает, как и ожидалось.

редактировать: Все раскрывается:

http://msdn.microsoft.com/en-US/library/wc3z3k8c(v=vs.80).aspx

Answer 4

Это происходит потому, что на этой линии:

n = ++n - new Nullable<int>(--i); 

я становится -1 и 2 - (-1) = 3;

Причина, по которой она становится отрицательной 1, заключается в том, что вы вводите объект nulluable, который инициализируется 0, а затем вычитает один (i).

вы можете запустить этот код как * .cshtml файл в вашем браузере:

@{ 

    int? m = 1; 
    int i = 1; 
    m = ++m - --i; 
    //MessageBox.Show("Without Nullable<int> n = {0}", n); //outputs n = 2 

    int? n = 1; 
    i = 1; 
    n = ++n - new Nullable<int>(--i); 
    //MessageBox.Show("With Nullable<int> n = {0}", n); //outputs n = 3 

} 

<!DOCTYPE html> 

<html lang="en"> 
<head> 
    <meta charset="utf-8" /> 
    <title></title> 
</head> 
<body> 
    <h2>m = @m</h2> 
    <h2>n = @n</h2> 
</body> 
</html>