Почему этот (null ||! TryParse) условный результат приводит к «использованию неназначенной локальной переменной»?

Следующий код приводит к использованию неназначенной локальной переменной numberOfGroups :

int numberOfGroups;
if(options.NumberOfGroups == null || !int.TryParse(options.NumberOfGroups, out numberOfGroups))
{
    numberOfGroups = 10;
}

Однако этот код работает нормально (хотя ReSharper говорит, что = 10он избыточен):

int numberOfGroups = 10;
if(options.NumberOfGroups == null || !int.TryParse(options.NumberOfGroups, out numberOfGroups))
{
    numberOfGroups = 10;
}

Мне что-то не хватает или компилятору не нравится мой ||?

Я сузил это до dynamicпричинения проблем ( optionsв моем приведенном выше коде была динамическая переменная). Остается вопрос, почему я не могу этого сделать ?

Этот код не компилируется:

internal class Program
{
    #region Static Methods

    private static void Main(string[] args)
    {
        dynamic myString = args[0];

        int myInt;
        if(myString == null || !int.TryParse(myString, out myInt))
        {
            myInt = 10;
        }

        Console.WriteLine(myInt);
    }

    #endregion
}

Однако этот код делает :

internal class Program
{
    #region Static Methods

    private static void Main(string[] args)
    {
        var myString = args[0]; // var would be string

        int myInt;
        if(myString == null || !int.TryParse(myString, out myInt))
        {
            myInt = 10;
        }

        Console.WriteLine(myInt);
    }

    #endregion
}

Я не понимал, dynamicчто это может быть фактором.

Я почти уверен, что это ошибка компилятора. Хорошая находка!

Изменить: это не ошибка, как демонстрирует Quartermeister; dynamic может реализовывать странный trueоператор, который может yникогда не инициализироваться.

Вот минимальное воспроизведение:

class Program
{
    static bool M(out int x) 
    { 
        x = 123; 
        return true; 
    }
    static int N(dynamic d)
    {
        int y;
        if(d || M(out y))
            y = 10;
        return y; 
    }
}

Я не вижу причин, почему это должно быть незаконно; если вы замените динамический на bool, он компилируется нормально.

Я действительно встречаюсь с командой C # завтра; Я скажу им об этом. Приносим извинения за ошибку!

Возможно, переменная не будет присвоена, если значение динамического выражения относится к типу с перегруженным trueоператором .

||Оператор будет вызывать trueоператор , чтобы решить , следует ли оценивать правую, а затем ifоператор будет вызывать trueоператор , чтобы решить , следует ли оценивать свое тело. В нормальном режиме boolони всегда будут возвращать один и тот же результат, поэтому будет оцениваться ровно один результат, но для пользовательского оператора такой гарантии нет!

Основываясь на репро Эрика Липперта, вот короткая и полная программа, которая демонстрирует случай, когда ни один путь не будет выполнен, а переменная будет иметь свое начальное значение:

using System;

class Program
{
    static bool M(out int x)
    {
        x = 123;
        return true;
    }

    static int N(dynamic d)
    {
        int y = 3;
        if (d || M(out y))
            y = 10;
        return y;
    }

    static void Main(string[] args)
    {
        var result = N(new EvilBool());
        // Prints 3!
        Console.WriteLine(result);
    }
}

class EvilBool
{
    private bool value;

    public static bool operator true(EvilBool b)
    {
        // Return true the first time this is called
        // and false the second time
        b.value = !b.value;
        return b.value;
    }

    public static bool operator false(EvilBool b)
    {
        throw new NotImplementedException();
    }
}

Из MSDN (выделено мной):

Динамический тип позволяет операциям, в которых он происходит, обойти проверку типа во время компиляции . Вместо этого эти операции разрешаются во время выполнения . Динамический тип упрощает доступ к COM API, таким как API автоматизации Office, а также к динамическим API, таким как библиотеки IronPython, и к объектной модели документа HTML (DOM).

Динамический тип в большинстве случаев ведет себя как типовой объект. Однако операции, содержащие выражения типа dynamic, не разрешаются и не проверяются компилятором.

Поскольку компилятор не проверяет типы и не разрешает какие-либо операции, содержащие выражения динамического типа, он не может гарантировать, что переменная будет назначена с помощью TryParse().