C # 4.0: ฉันสามารถใช้ TimeSpan เป็นพารามิเตอร์เสริมที่มีค่าเริ่มต้นได้หรือไม่

ทั้งสองอย่างนี้สร้างข้อผิดพลาดที่บอกว่าต้องเป็นค่าคงที่เวลาคอมไพล์:

void Foo(TimeSpan span = TimeSpan.FromSeconds(2.0))
void Foo(TimeSpan span = new TimeSpan(2000))

ก่อนอื่นใครสามารถอธิบายได้ว่าทำไมค่าเหล่านี้ไม่สามารถกำหนดได้ในเวลารวบรวม? และมีวิธีระบุค่าดีฟอลต์สำหรับอ็อบเจ็กต์ TimeSpan หรือไม่?

คุณสามารถแก้ไขปัญหานี้ได้อย่างง่ายดายโดยเปลี่ยนลายเซ็นของคุณ

void Foo(TimeSpan? span = null) {

   if (span == null) { span = TimeSpan.FromSeconds(2); }

   ...

}

ฉันควรอธิบายให้ละเอียด - เหตุผลที่นิพจน์เหล่านั้นในตัวอย่างของคุณไม่ใช่ค่าคงที่เวลาคอมไพล์เนื่องจากในเวลาคอมไพล์คอมไพเลอร์ไม่สามารถเรียกใช้งาน TimeSpan.FromSeconds (2.0) และใส่ไบต์ของผลลัพธ์ลงในโค้ดที่คอมไพล์ของคุณได้

ตัวอย่างเช่นพิจารณาว่าคุณพยายามใช้ DateTime.Now แทนหรือไม่ ค่าของ DateTime ตอนนี้เปลี่ยนทุกครั้งที่ดำเนินการ หรือสมมติว่า TimeSpan.FromSeconds คำนึงถึงแรงโน้มถ่วง เป็นตัวอย่างที่ไร้สาระ แต่กฎของค่าคงที่เวลาคอมไพล์ไม่ได้สร้างกรณีพิเศษเพียงเพราะเรารู้ว่า TimeSpan.FromSeconds เป็นตัวกำหนด

มรดก VB6 ของฉันทำให้ฉันไม่สบายใจกับความคิดที่จะพิจารณา "ค่าว่าง" และ "ค่าที่ขาดหายไป" ให้เทียบเท่ากัน ในกรณีส่วนใหญ่อาจเป็นเรื่องปกติ แต่คุณอาจมีผลข้างเคียงที่ไม่ได้ตั้งใจหรือคุณอาจกลืนเงื่อนไขพิเศษ (เช่นหากแหล่งที่มาspanเป็นคุณสมบัติหรือตัวแปรที่ไม่ควรเป็นค่าว่าง แต่เป็น)

ดังนั้นฉันจะใช้วิธีนี้มากเกินไป:

void Foo()
{
    Foo(TimeSpan.FromSeconds(2.0));
}
void Foo(TimeSpan span)
{
    //...
}

ใช้งานได้ดี:

void Foo(TimeSpan span = default(TimeSpan))

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

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

C # 6.0 - ประเภทพารามิเตอร์แอตทริบิวต์ :

ประเภทของพารามิเตอร์ตำแหน่งและชื่อสำหรับคลาสแอ็ตทริบิวต์ถูก จำกัด ไว้ที่ประเภทพารามิเตอร์แอ็ตทริบิวต์ซึ่ง ได้แก่ :

• ประเภทใดประเภทหนึ่งต่อไปนี้: bool` byte` char, double` float` int, long` sbyte` short, string` uint` ulong, ushort.
• objectประเภท
• System.Typeประเภท
• ประเภท enum
  ^{(หากมีการเข้าถึงแบบสาธารณะและประเภทที่ซ้อนอยู่ (ถ้ามี) มีการเข้าถึงแบบสาธารณะด้วย)}
• อาร์เรย์มิติเดียวประเภทข้างต้น

ประเภทTimeSpanไม่พอดีกับรายการเหล่านี้ดังนั้นจึงไม่สามารถใช้เป็นค่าคงที่ได้

void Foo(TimeSpan span = default(TimeSpan))
{
    if (span == default(TimeSpan)) 
        span = TimeSpan.FromSeconds(2); 
}

ที่ระบุdefault(TimeSpan)ไม่ใช่ค่าที่ถูกต้องสำหรับฟังก์ชัน

หรือ

//this works only for value types which TimeSpan is
void Foo(TimeSpan span = new TimeSpan())
{
    if (span == new TimeSpan()) 
        span = TimeSpan.FromSeconds(2); 
}

ที่ระบุnew TimeSpan()ไม่ใช่ค่าที่ถูกต้อง

หรือ

void Foo(TimeSpan? span = null)
{
    if (span == null) 
        span = TimeSpan.FromSeconds(2); 
}

สิ่งนี้ควรจะดีกว่าเมื่อพิจารณาถึงโอกาสที่nullค่าจะเป็นค่าที่ถูกต้องสำหรับฟังก์ชันนั้นหายาก

TimeSpanเป็นกรณีพิเศษสำหรับDefaultValueAttributeและระบุโดยใช้สตริงใด ๆ ที่สามารถแยกวิเคราะห์ผ่านTimeSpan.Parseวิธีการ

[DefaultValue("0:10:0")]
public TimeSpan Duration { get; set; }

คำแนะนำของฉัน:

void A( long spanInMs = 2000 )
{
    var ts = TimeSpan.FromMilliseconds(spanInMs);

    //...
}

BTW TimeSpan.FromSeconds(2.0)ไม่เท่ากันnew TimeSpan(2000)- ตัวสร้างใช้เห็บ

คำตอบอื่น ๆได้ให้คำอธิบายที่ดีว่าเหตุใดพารามิเตอร์ทางเลือกจึงไม่สามารถเป็นนิพจน์แบบไดนามิกได้ แต่หากต้องการนับใหม่พารามิเตอร์เริ่มต้นจะทำงานเหมือนค่าคงที่ของเวลาในการคอมไพล์ นั่นหมายความว่าคอมไพลเลอร์ต้องสามารถประเมินและหาคำตอบได้ มีบางคนที่ต้องการให้ C # เพิ่มการสนับสนุนสำหรับคอมไพลเลอร์ที่ประเมินนิพจน์แบบไดนามิกเมื่อพบการประกาศค่าคงที่คุณลักษณะประเภทนี้จะเกี่ยวข้องกับวิธีการทำเครื่องหมายว่า "บริสุทธิ์" แต่นั่นไม่ใช่ความจริงในตอนนี้และอาจจะไม่มีเลย

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

public class FooSettings
{
    public TimeSpan Span { get; set; } = TimeSpan.FromSeconds(2);

    // I imagine that if you had a heavyweight default
    // thing you’d want to avoid instantiating it right away
    // because the caller might override that parameter. So, be
    // lazy! (Or just directly store a factory lambda with Func<IThing>).
    Lazy<IThing> thing = new Lazy<IThing>(() => new FatThing());
    public IThing Thing
    {
        get { return thing.Value; }
        set { thing = new Lazy<IThing>(() => value); }
    }

    // Another cool thing about this pattern is that you can
    // add additional optional parameters in the future without
    // even breaking ABI.
    //bool FutureThing { get; set; } = true;

    // You can even run very complicated code to populate properties
    // if you cannot use a property initialization expression.
    //public FooSettings() { }
}

public class Bar
{
    public void Foo(FooSettings settings = null)
    {
        // Allow the caller to use *all* the defaults easily.
        settings = settings ?? new FooSettings();

        Console.WriteLine(settings.Span);
    }
}

ในการเรียกใช้ไวยากรณ์แปลก ๆ เพื่อสร้างอินสแตนซ์และกำหนดคุณสมบัติทั้งหมดในนิพจน์เดียว:

bar.Foo(); // 00:00:02
bar.Foo(new FooSettings { Span = TimeSpan.FromDays(1), }); // 1.00:00:00
bar.Foo(new FooSettings { Thing = new MyCustomThing(), }); // 00:00:02

ข้อเสีย

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

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

ประโยชน์ที่ได้รับ

ดังที่ฉันได้กล่าวไว้ในความคิดเห็นในตัวอย่างฉันคิดว่ารูปแบบนี้เหมาะสำหรับ API สาธารณะ การเพิ่มคุณสมบัติใหม่ให้กับคลาสเป็นการเปลี่ยนแปลง ABI ที่ไม่ทำลายดังนั้นคุณสามารถเพิ่มพารามิเตอร์ทางเลือกใหม่โดยไม่ต้องเปลี่ยนลายเซ็นของวิธีการของคุณโดยใช้รูปแบบนี้ทำให้โค้ดที่คอมไพล์ล่าสุดมีตัวเลือกมากขึ้นในขณะที่ยังคงรองรับโค้ดที่คอมไพล์เก่าโดยไม่ต้องทำงานเพิ่มเติม .

นอกจากนี้เนื่องจากพารามิเตอร์เมธอดเริ่มต้นที่สร้างขึ้นใน C # จะถือว่าเป็นค่าคงที่ของเวลาคอมไพล์และอบลงใน callite พารามิเตอร์เริ่มต้นจะถูกใช้โดยรหัสเมื่อมีการคอมไพล์ใหม่เท่านั้น โดยการสร้างอินสแตนซ์ออบเจ็กต์การตั้งค่าผู้เรียกจะโหลดค่าเริ่มต้นแบบไดนามิกเมื่อเรียกใช้เมธอดของคุณ ซึ่งหมายความว่าคุณสามารถอัปเดตค่าเริ่มต้นได้เพียงแค่เปลี่ยนคลาสการตั้งค่าของคุณ ดังนั้นรูปแบบนี้ช่วยให้คุณสามารถเปลี่ยนค่าเริ่มต้นได้โดยไม่ต้องคอมไพล์ผู้โทรใหม่เพื่อดูค่าใหม่หากต้องการ