เหตุใดเงื่อนไข (null ||! tryParse) จึงทำให้เกิด "การใช้ตัวแปรภายในที่ไม่ได้กำหนด"

โค้ดต่อไปนี้ส่งผลให้ใช้ตัวแปรโลคัล "numberOfGroups" ที่ไม่ได้กำหนด :

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

อย่างไรก็ตามรหัสนี้ใช้งานได้ดี (แม้ว่าReSharperกล่าวว่า= 10ซ้ำซ้อน):

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

ฉันขาดอะไรไปหรือคอมไพเลอร์ไม่ชอบของฉัน||?

ฉันได้ จำกัด สิ่งนี้ให้แคบลงจนdynamicทำให้เกิดปัญหา ( optionsเป็นตัวแปรแบบไดนามิกในโค้ดด้านบนของฉัน) คำถามยังคงอยู่ทำไมฉันถึงทำสิ่งนี้ไม่ได้?

รหัสนี้ไม่ได้รวบรวม:

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
}

อย่างไรก็ตามรหัสนี้ทำ :

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
}

ฉันไม่รู้ว่าdynamicจะเป็นปัจจัยในเรื่องนี้

ฉันค่อนข้างมั่นใจว่านี่เป็นบั๊กของคอมไพเลอร์ พบดี!

แก้ไข: ไม่ใช่ข้อผิดพลาดอย่างที่ Quartermeister แสดงให้เห็น ไดนามิกอาจใช้ตัวดำเนินการแปลก ๆtrueซึ่งอาจทำให้yไม่มีการเตรียมใช้งาน

นี่เป็นคำแนะนำขั้นต่ำ:

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

ฉันไม่เห็นเหตุผลว่าทำไมจึงควรผิดกฎหมาย ถ้าคุณแทนที่ไดนามิกด้วยบูลมันจะคอมไพล์ได้ดี

พรุ่งนี้ฉันจะพบกับทีม C # ฉันจะพูดถึงพวกเขา ขออภัยในความผิดพลาด!

เป็นไปได้ที่ตัวแปรจะไม่ถูกกำหนดหากค่าของนิพจน์ไดนามิกเป็นประเภทที่มีตัวดำเนินการมากเกินไปtrueผู้ประกอบการ

ตัว||ดำเนินการจะเรียกให้trueโอเปอเรเตอร์ตัดสินใจว่าจะประเมินด้านขวามือหรือไม่จากนั้นifคำสั่งจะเรียกให้ตัวtrueดำเนินการตัดสินใจว่าจะประเมินร่างกายหรือไม่ สำหรับคนปกติboolแล้วสิ่งเหล่านี้จะส่งคืนผลลัพธ์เดียวกันเสมอและจะได้รับการประเมินอย่างแน่นอน แต่สำหรับตัวดำเนินการที่ผู้ใช้กำหนดเองไม่มีการรับประกันเช่นนั้น!

จาก repro ของ Eric Lippert ต่อไปนี้เป็นโปรแกรมสั้น ๆ และสมบูรณ์ที่แสดงให้เห็นถึงกรณีที่จะไม่มีการเรียกใช้เส้นทางใดและตัวแปรจะมีค่าเริ่มต้น:

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 (เน้นของฉัน):

ชนิดแบบไดนามิกจะช่วยให้การดำเนินงานในการที่จะเกิดขึ้นกับบายพาสเวลารวบรวมตรวจสอบประเภท แต่การดำเนินการเหล่านี้จะได้รับการแก้ไขในขณะทำงานได้รับการแก้ไขในเวลาทำงานประเภทไดนามิกช่วยลดความยุ่งยากในการเข้าถึง COM API เช่น Office Automation API และ API แบบไดนามิกเช่นไลบรารี IronPython และ HTML Document Object Model (DOM)

ประเภทไดนามิกจะทำงานเหมือนวัตถุประเภทในสถานการณ์ส่วนใหญ่ อย่างไรก็ตามการดำเนินการที่มีนิพจน์ประเภทไดนามิกไม่ได้รับการแก้ไขหรือตรวจสอบประเภทโดยคอมไพลเลอร์

เนื่องจากคอมไพลเลอร์ไม่พิมพ์ check หรือแก้ไขการดำเนินการใด ๆ ที่มีนิพจน์ประเภทไดนามิกจึงไม่สามารถรับรองได้ว่าตัวแปรจะถูกกำหนดผ่านการใช้TryParse().