Dlaczego ten warunek (null ||! TryParse) powoduje "użycie nieprzypisanej zmiennej lokalnej"?

Question

Poniższe wyniki kodowe w wykorzystania nieprzypisanych zmiennej lokalnej "numberOfGroups":

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

Jednak ten kod działa poprawnie (choć ReSharper mówi = 10 jest zbędny):

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

Am Brakuje mi czegoś lub kompilator nie lubi mojego ||?

Zawęziłem to do dynamic, powodując problemy (options była zmienną dynamiczną w powyższym kodzie). Pozostaje pytanie, dlaczego nie mogę tego zrobić?

Ten kod nie kompilacji:

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 
} 

Jednak ten kod robi:

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 
} 

nie zdawałem sobie sprawy dynamic będzie czynnikiem w tej sprawie.

Answer 1

Jestem prawie pewien, że jest to błąd kompilatora. Ładne znalezisko!

Edycja: to nie jest błąd, jak pokazuje Quartermeister; dynamic może zaimplementować dziwny operator true, który może spowodować, że y nie zostanie zainicjowany.

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

nie widzę powodu, dlaczego tak powinno być nielegalne; jeśli zamienisz dynamicznie na bool, kompiluje się dobrze.

Naprawdę spotykam się jutro z zespołem C#; Wspomnę o tym im. Przepraszamy za błąd!

Answer 2

From MSDN (Kopalnia nacisk):

The dynamic type enables the operations in which it occurs to bypass compile-time type checking. Instead, these operations are resolved at run time. The dynamic type simplifies access to COM APIs such as the Office Automation APIs, and also to dynamic APIs such as IronPython libraries, and to the HTML Document Object Model (DOM).

Type dynamic behaves like type object in most circumstances. However, operations that contain expressions of type dynamic are not resolved or type checked by the compiler.

Ponieważ kompilator nie typ kontroli lub rozwiązać wszelkie operacje, które zawierają wyrażenia typu dynamicznego, nie może zapewnić, że zmienna będzie przypisana poprzez wykorzystanie TryParse().

Answer 3

Możliwe jest, że zmienna zostanie cofnięta, jeśli wartość dynamicznego wyrażenia jest przeciążona przeciążonym operatorem.

Operator || będzie wywoływał operatora true zdecydować, czy do oceny prawą stronę, a następnie stwierdzenie if będzie wywoływał operatora true do decydowania o ocenę jego ciało. W przypadku normalnego bool, zawsze będą zwracać ten sam wynik, więc dokładnie jeden zostanie oceniony, ale dla operatora zdefiniowanego przez użytkownika nie ma takiej gwarancji!

budynku off Repro Eric Lippert, oto jest krótki i kompletny program, który pokazuje przypadek, w którym żadna ścieżka będzie wykonywana i zmienna miałaby swoją pierwotną wartość:

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