Pourquoi cette condition (null ||! TryParse) aboutit-elle à «l'utilisation d'une variable locale non affectée»?

Le code suivant entraîne l' utilisation de la variable locale non attribuée "numberOfGroups" :

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

Cependant, ce code fonctionne bien (cependant, ReSharper dit que le = 10est redondant):

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

Est-ce que je manque quelque chose ou est-ce que le compilateur n'aime pas mon ||?

J'ai réduit cela à la dynamiccause des problèmes ( optionsc'était une variable dynamique dans mon code ci-dessus). La question demeure, pourquoi je ne peux pas faire ça ?

Ce code ne compile pas :

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
}

Cependant, ce code fait :

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
}

Je n'avais pas réalisé que ce dynamicserait un facteur.

Je suis presque sûr que c'est un bogue du compilateur. Bonne trouvaille!

Edit: ce n'est pas un bug, comme le démontre Quartermeister; dynamic pourrait implémenter un trueopérateur étrange qui pourrait empêcher yl'initialisation.

Voici un repro minimal:

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

Je ne vois aucune raison pour laquelle cela devrait être illégal; si vous remplacez dynamic par bool, il se compile très bien.

Je rencontre actuellement l'équipe C # demain; Je vais leur en parler. Toutes mes excuses pour l'erreur!

Il est possible que la variable soit désassignée si la valeur de l'expression dynamique est d'un type avec un opérateur surchargétrue .

L' ||opérateur invoquera l' trueopérateur pour décider s'il doit évaluer le côté droit, puis l' ifinstruction invoquera l' trueopérateur pour décider s'il doit évaluer son corps. Pour un normal bool, ceux-ci renverront toujours le même résultat et donc exactement un sera évalué, mais pour un opérateur défini par l'utilisateur, il n'y a pas une telle garantie!

Sur la base de la repro d'Eric Lippert, voici un programme court et complet qui démontre un cas où aucun chemin ne serait exécuté et la variable aurait sa valeur initiale:

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 (c'est moi qui souligne):

Le type dynamique permet aux opérations dans lesquelles il se produit de contourner la vérification de type à la compilation . Au lieu de cela, ces opérations sont résolues au moment de l'exécution . Le type dynamique simplifie l'accès aux API COM telles que les API Office Automation, ainsi qu'aux API dynamiques telles que les bibliothèques IronPython et au modèle d'objet de document HTML (DOM).

Le type dynamic se comporte comme un objet de type dans la plupart des cas. Cependant, les opérations qui contiennent des expressions de type dynamic ne sont pas résolues ou vérifiées par le compilateur.

Étant donné que le compilateur ne contrôle ni ne résout aucune opération contenant des expressions de type dynamic, il ne peut garantir que la variable sera affectée via l'utilisation de TryParse().