¿Por qué este condicional (nulo ||! TryParse) da como resultado un "uso de una variable local no asignada"?

El siguiente código da como resultado el uso de la variable local no asignada "numberOfGroups" :

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

Sin embargo, este código funciona bien (aunque ReSharper dice que = 10es redundante):

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

¿Me falta algo o al compilador no le gusta mi ||?

He reducido esto para dynamiccausar los problemas ( optionsera una variable dinámica en mi código anterior). La pregunta sigue siendo, ¿por qué no puedo hacer esto ?

Este código no se 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
}

Sin embargo, este código sí :

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
}

No me di cuenta de dynamicque sería un factor en esto.

Estoy bastante seguro de que se trata de un error del compilador. ¡Buen hallazgo!

Editar: no es un error, como demuestra Quartermeister; dynamic podría implementar un trueoperador extraño que podría causar yque nunca se inicialice.

Aquí hay una reproducción 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; 
    }
}

No veo ninguna razón por la que eso deba ser ilegal; si reemplaza dynamic con bool, se compila bien.

De hecho, mañana me reuniré con el equipo de C #; Se lo mencionaré. ¡Disculpas por el error!

Es posible que la variable no esté asignada si el valor de la expresión dinámica es de un tipo con un operador sobrecargadotrue .

El ||operador invocará al trueoperador para decidir si evaluar el lado derecho, y luego la ifdeclaración invocará al trueoperador para decidir si evaluar su cuerpo. Para una normal bool, estos siempre devolverán el mismo resultado y, por lo tanto, se evaluará exactamente uno, ¡pero para un operador definido por el usuario no existe tal garantía!

Partiendo de la reproducción de Eric Lippert, aquí hay un programa corto y completo que demuestra un caso en el que ninguna ruta se ejecutaría y la variable tendría su 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();
    }
}

De MSDN (el énfasis es mío):

El tipo dinámico permite que las operaciones en las que se produce eludan la comprobación de tipos en tiempo de compilación . En cambio, estas operaciones se resuelven en tiempo de ejecución . El tipo dinámico simplifica el acceso a las API COM, como las API de Office Automation, y también a las API dinámicas, como las bibliotecas IronPython, y al modelo de objetos de documento HTML (DOM).

El tipo dinámico se comporta como un objeto de tipo en la mayoría de las circunstancias. Sin embargo, las operaciones que contienen expresiones de tipo dinámico no son resueltas ni verificadas por el compilador.

Dado que el compilador no comprueba el tipo ni resuelve ninguna operación que contenga expresiones de tipo dinámico, no puede asegurar que la variable se asignará mediante el uso de TryParse().