Bu (null ||! TryParse) koşulu neden “atanmamış yerel değişken kullanımı” ile sonuçlanıyor?

Aşağıdaki kod , atanmamış yerel değişken "numberOfGroups" kullanımıyla sonuçlanır :

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

Bununla birlikte, bu kod iyi çalışıyor ( ReSharper bunun = 10gereksiz olduğunu söylüyor ):

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

Bir şey mi kaçırıyorum yoksa derleyici benden hoşlanmıyor ||mu?

Bunu dynamicsorunlara neden olacak şekilde daralttım ( optionsyukarıdaki kodumda dinamik bir değişkendi). Soru hala duruyor, neden bunu yapamıyorum ?

Bu kod değil derleme:

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
}

Ancak bu kod şunları yapar :

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
}

Bunda dynamicbir faktör olacağını bilmiyordum .

Bunun bir derleyici hatası olduğundan oldukça eminim. Güzel bul!

Düzenleme: Quartermeister'ın gösterdiği gibi bu bir hata değildir; dynamic , hiçbir zaman başlatılmamasına trueneden olabilecek garip bir işleç uygulayabilir y.

İşte minimal bir 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; 
    }
}

Bunun yasa dışı olması için hiçbir neden göremiyorum; dynamic'i bool ile değiştirirseniz, gayet iyi derler.

Aslında yarın C # ekibiyle buluşuyorum; Onlara bundan bahsedeceğim. Hata için özür dileriz!

Dinamik ifadenin değeri aşırı yüklenmiş bir trueoperatörü olan bir türdeyse, değişkenin atanmamış olması mümkündür .

||Operatör çağıracağı truesağ tarafını değerlendirmek için karar vermek operatörü ve sonra ififadesi çağıracağı trueonun vücudunu değerlendirmek için karar vermek operatörü. Normalde boolbunlar her zaman aynı sonucu verir ve bu nedenle tam olarak biri değerlendirilir, ancak kullanıcı tanımlı bir operatör için böyle bir garanti yoktur!

Eric Lippert'in reprosundan yola çıkarak, burada hiçbir yolun yürütülemeyeceği ve değişkenin başlangıç ​​değerine sahip olacağı bir durumu gösteren kısa ve eksiksiz bir program var:

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

MSDN'den (vurgu benim):

Dinamik tür, derleme zamanı tür denetimini atlamak için meydana geldiği işlemleri etkinleştirir . Bunun yerine, bu işlemler çalışma zamanında çözülür . Dinamik tür, Office Otomasyon API'leri gibi COM API'lerine ve ayrıca IronPython kitaplıkları gibi dinamik API'lere ve HTML Belge Nesne Modeli'ne (DOM) erişimi basitleştirir.

Type dynamic, çoğu durumda tür nesnesi gibi davranır. Ancak, dinamik türünde ifadeler içeren işlemler çözümlenmez veya derleyici tarafından tür denetlenmez.

Derleyici, dinamik türünde ifadeler içeren herhangi bir işlem denetimi yazmadığı veya çözümlemediği için, değişkenin kullanımıyla atanacağını garanti edemez TryParse().