Perché questo condizionale (null ||! TryParse) comporta "l'uso di una variabile locale non assegnata"?

Il codice seguente comporta l' utilizzo della variabile locale non assegnata "numberOfGroups" :

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

Tuttavia, questo codice funziona bene (sebbene, ReSharper dice che = 10è ridondante):

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

Mi manca qualcosa o al compilatore non piace il mio ||?

L'ho ristretto per dynamiccausare i problemi ( optionsera una variabile dinamica nel mio codice sopra). La domanda rimane ancora, perché non posso farlo ?

Questo codice non viene compilato:

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
}

Tuttavia, questo codice fa :

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
}

Non mi rendevo conto che dynamicsarebbe stato un fattore in questo.

Sono abbastanza sicuro che questo sia un bug del compilatore. Bella scoperta!

Modifica: non è un bug, come dimostra Quartermeister; dynamic potrebbe implementare uno strano trueoperatore che potrebbe ynon essere mai inizializzato.

Ecco una riproduzione minima:

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

Non vedo motivo per cui dovrebbe essere illegale; se sostituisci dynamic con bool, si compila bene.

Domani incontrerò il team C #; Ne parlerò a loro. Mi scuso per l'errore!

È possibile annullare l'assegnazione della variabile se il valore dell'espressione dinamica è di un tipo con un operatore sovraccaricotrue .

L' ||operatore chiamerà l' trueoperatore per decidere se valutare il lato destro, quindi l' ifistruzione chiamerà l' trueoperatore per decidere se valutare il suo corpo. Per un normale bool, questi restituiranno sempre lo stesso risultato e quindi ne verrà valutato esattamente uno, ma per un operatore definito dall'utente non esiste tale garanzia!

Partendo dalla riproduzione di Eric Lippert, ecco un programma breve e completo che mostra un caso in cui nessuno dei percorsi verrebbe eseguito e la variabile avrebbe il suo valore iniziale:

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

Da MSDN (enfasi mia):

Il tipo dinamico consente alle operazioni in cui si verifica di ignorare il controllo del tipo in fase di compilazione . Queste operazioni vengono invece risolte in fase di esecuzione . Il tipo dinamico semplifica l'accesso alle API COM come le API di Office Automation e anche alle API dinamiche come le librerie IronPython e al DOM (Document Object Model) HTML.

Il tipo dinamico si comporta come l'oggetto di tipo nella maggior parte delle circostanze. Tuttavia, le operazioni che contengono espressioni di tipo dinamico non vengono risolte o il tipo controllato dal compilatore.

Poiché il compilatore non esegue il controllo del tipo né risolve alcuna operazione che contiene espressioni di tipo dinamico, non può garantire che la variabile verrà assegnata tramite l'uso di TryParse().