Warum führt diese (null ||! TryParse) Bedingung zur Verwendung einer nicht zugewiesenen lokalen Variablen?

Der folgende Code führt zur Verwendung der nicht zugewiesenen lokalen Variablen "numberOfGroups" :

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

Allerdings funktioniert dieser Code in Ordnung (obwohl, ReSharper , sagt der = 10überflüssig ist):

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

Vermisse ich etwas oder mag der Compiler meine nicht ||?

Ich habe dies eingegrenzt, dynamicum die Probleme zu verursachen ( optionswar eine dynamische Variable in meinem obigen Code). Es bleibt die Frage, warum ich das nicht tun kann .

Dieser Code wird nicht kompiliert:

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
}

Dieser Code bewirkt jedoch :

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
}

Ich wusste nicht, dynamicdass dies ein Faktor sein würde.

Ich bin mir ziemlich sicher, dass dies ein Compiler-Fehler ist. Schöner Fund!

Bearbeiten: Es ist kein Fehler, wie Quartermeister demonstriert; dynamic implementiert möglicherweise einen seltsamen trueOperator, der dazu führen kann y, dass er niemals initialisiert wird.

Hier ist ein minimaler Repro:

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

Ich sehe keinen Grund, warum das illegal sein sollte; Wenn Sie Dynamic durch Bool ersetzen, wird es problemlos kompiliert.

Ich treffe mich morgen mit dem C # -Team. Ich werde es ihnen gegenüber erwähnen. Entschuldigung für den Fehler!

Es ist möglich, dass die Variable nicht zugewiesen wird, wenn der Wert des dynamischen Ausdrucks von einem Typ mit einem überladenen trueOperator ist .

Der ||Bediener ruft den trueBediener auf, um zu entscheiden, ob die rechte Seite bewertet werden soll, und dann ifruft die Anweisung den trueBediener auf, um zu entscheiden, ob der Körper bewertet werden soll. Für einen Normalen geben booldiese immer das gleiche Ergebnis zurück und so wird genau eines ausgewertet, aber für einen benutzerdefinierten Operator gibt es keine solche Garantie!

Aufbauend auf Eric Lipperts Repro ist hier ein kurzes und vollständiges Programm, das einen Fall demonstriert, in dem keiner der Pfade ausgeführt wird und die Variable ihren Anfangswert hat:

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

Von MSDN (Schwerpunkt Mine):

Der dynamische Typ ermöglicht es den Operationen, in denen er auftritt, die Typprüfung zur Kompilierungszeit zu umgehen . Stattdessen werden diese Vorgänge zur Laufzeit aufgelöst . Der dynamische Typ vereinfacht den Zugriff auf COM-APIs wie die Office Automation-APIs sowie auf dynamische APIs wie IronPython-Bibliotheken und auf das HTML Document Object Model (DOM).

Typendynamik verhält sich in den meisten Fällen wie Typobjekt. Allerdings Operationen , die Ausdrücke vom Typ dynamischen enthalten , werden nicht aufgelöst oder Typ vom Compiler geprüft.

Da der Compiler keine Operationen prüft oder auflöst, die Ausdrücke vom Typ dynamisch enthalten, kann er nicht sicherstellen, dass die Variable mithilfe von zugewiesen wird TryParse().