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

Poniższy kod powoduje użycie nieprzypisanej zmiennej lokalnej „numberOfGroups” :

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

Jednak ten kod działa dobrze (chociaż ReSharper twierdzi, że = 10jest zbędny):

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

Czy coś mi brakuje, czy kompilator nie lubi mojego ||?

Zawęziłem to do dynamicpowodowania problemów ( optionsbyła to zmienna dynamiczna w moim powyższym kodzie). Pozostaje pytanie, dlaczego nie mogę tego zrobić ?

Ten kod nie kompiluje się:

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że będzie to miało znaczenie.

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

Edycja: to nie jest błąd, jak demonstruje Quartermeister; Dynamic może zaimplementować dziwny trueoperator, który może spowodować, yże nigdy nie zostanie zainicjowany.

Oto minimalna reprodukcja:

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, dla którego miałoby to być nielegalne; jeśli zamienisz dynamic na bool, kompiluje się dobrze.

Właściwie mam jutro spotkanie z zespołem C #; Wspomnę im o tym. Przepraszamy za błąd!

Zmienna może zostać nieprzypisana, jeśli wartość wyrażenia dynamicznego jest typu z przeciążonym trueoperatorem .

||Operator będzie wywołać trueoperatora zdecydować, czy do oceny prawą stronę, a następnie ifoświadczenie będzie wywołać trueoperatora do decydowania o ocenę jego ciało. W przypadku normalnych wyników boolzawsze będą one zwracać ten sam wynik, więc dokładnie jeden zostanie oceniony, ale w przypadku operatora zdefiniowanego przez użytkownika nie ma takiej gwarancji!

Opierając się na reprodukcji Erica Lipperta, oto krótki i kompletny program, który demonstruje przypadek, w którym żadna ścieżka nie zostanie wykonana, a zmienna będzie miała swoją początkową 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();
    }
}

Z MSDN (wyróżnienie moje):

Typ dynamiczny umożliwia operacjom, w których występuje, pomijanie sprawdzania typu w czasie kompilacji . Zamiast tego te operacje są rozwiązywane w czasie wykonywania . Typ dynamiczny upraszcza dostęp do interfejsów API COM, takich jak interfejsy API automatyzacji pakietu Office, a także do dynamicznych interfejsów API, takich jak biblioteki IronPython, oraz do modelu obiektu dokumentu HTML (DOM).

Dynamiczny typ zachowuje się w większości przypadków jak obiekt tekstu. Jednak operacje zawierające wyrażenia typu dynamic nie są rozpoznawane ani sprawdzane przez kompilator.

Ponieważ kompilator nie sprawdza typów ani nie rozwiązuje żadnych operacji, które zawierają wyrażenia typu dynamic, nie może zagwarantować, że zmienna zostanie przypisana za pomocą TryParse().