Por que isso (null ||! TryParse) resulta em “uso de variável local não atribuída”?

O código a seguir resulta no uso da variável local não atribuída "numberOfGroups" :

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

No entanto, este código funciona bem (embora ReSharper diga que o = 10é redundante):

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

Estou perdendo algo ou o compilador não está gostando do meu ||?

Eu reduzi isso para dynamiccausar os problemas ( optionsera uma variável dinâmica no meu código acima). A questão ainda permanece, por que não posso fazer isso ?

Este código não compila:

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
}

No entanto, este código faz :

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
}

Eu não sabia que dynamicisso seria um fator.

Tenho certeza de que é um bug do compilador. Belo achado!

Edit: não é um bug, como demonstra Quartermeister; dynamic pode implementar um trueoperador estranho que pode fazer ycom que nunca seja inicializado.

Aqui está uma reprodução mínima:

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; 
    }
}

Não vejo razão para que isso seja ilegal; se você substituir dynamic por bool, ele compilará perfeitamente.

Na verdade, vou me encontrar com a equipe C # amanhã; Vou mencionar isso a eles. Desculpas pelo erro!

É possível que a variável não seja atribuída se o valor da expressão dinâmica for de um tipo com um operador sobrecarregadotrue .

O ||operador invocará o trueoperador para decidir se avalia o lado direito e, em seguida, a ifinstrução invocará o trueoperador para decidir se avalia seu corpo. Para um normal bool, eles sempre retornarão o mesmo resultado e então exatamente um será avaliado, mas para um operador definido pelo usuário não existe tal garantia!

Construindo a partir da reprodução de Eric Lippert, aqui está um programa curto e completo que demonstra um caso em que nenhum caminho seria executado e a variável teria seu valor inicial:

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();
    }
}

Do MSDN (ênfase minha):

O tipo dinâmico permite que as operações em que ele ocorre ignorem a verificação de tipo em tempo de compilação . Em vez disso, essas operações são resolvidas em tempo de execução . O tipo dinâmico simplifica o acesso a APIs COM, como APIs de automação do Office, e também a APIs dinâmicas, como bibliotecas IronPython e ao HTML Document Object Model (DOM).

O tipo dinâmico se comporta como um objeto de texto na maioria das circunstâncias. No entanto, as operações que contêm expressões do tipo dinâmico não são resolvidas ou verificadas pelo compilador.

Visto que o compilador não verifica o tipo ou resolve nenhuma operação que contenha expressões do tipo dinâmico, ele não pode garantir que a variável será atribuída por meio do uso de TryParse().