เป็นโมฆะใน C # generics?

ฉันมีวิธีการทั่วไปที่รับคำขอและให้การตอบกลับ

public Tres DoSomething<Tres, Treq>(Tres response, Treq request)
{/*stuff*/}

แต่ฉันไม่ต้องการคำตอบสำหรับคำขอของฉันเสมอไปและฉันไม่ต้องการป้อนข้อมูลคำขอเพื่อรับคำตอบเสมอไป ฉันไม่ต้องการคัดลอกและวางวิธีการทั้งหมดเพื่อทำการเปลี่ยนแปลงเล็กน้อย สิ่งที่ฉันต้องการคือสามารถทำได้:

public Tre DoSomething<Tres>(Tres response)
{
    return DoSomething<Tres, void>(response, null);
}

เป็นไปได้ในบางลักษณะหรือไม่? ดูเหมือนว่าการใช้ void โดยเฉพาะจะไม่ได้ผล แต่ฉันหวังว่าจะพบบางสิ่งที่คล้ายคลึงกัน

คุณไม่สามารถใช้งานได้voidแต่คุณสามารถใช้ได้object: มันเป็นความไม่สะดวกเล็กน้อยเนื่องจากvoidฟังก์ชันที่คุณต้องการจะต้องส่งคืนnullแต่หากรวมรหัสของคุณเข้าด้วยกันก็ควรเป็นราคาที่ต้องจ่ายเล็กน้อย

ไร้ความสามารถนี้จะใช้voidเป็นชนิดกลับเป็นอย่างน้อยบางส่วนรับผิดชอบในการแยกระหว่างการFunc<...>และAction<...>ครอบครัวของผู้ได้รับมอบหมายทั่วไป: มันมีความเป็นไปได้ที่จะกลับมาvoidทั้งหมดจะกลายเป็นเพียงAction<X,Y,Z> Func<X,Y,Z,void>น่าเสียดายที่ไม่สามารถทำได้

ไม่น่าเสียดายที่ไม่ ถ้าvoidเป็นคนประเภท "จริง" (เช่นunitใน F #เป็นต้น) ชีวิตจะง่ายกว่านี้มากในหลาย ๆ ด้าน โดยเฉพาะอย่างยิ่งเราจะไม่จำเป็นต้องใช้ทั้งFunc<T>และAction<T>ครอบครัว - มีเพียงแค่ต้องการจะFunc<void>แทนAction, Func<T, void>แทนAction<T>ฯลฯ

นอกจากนี้ยังจะทำให้ async ง่าย - มันน่าจะมีความจำเป็นในการที่ไม่ใช่ทั่วไปไม่มีTaskประเภทที่ทั้งหมด - Task<void>เราต้องการเพียงแค่มี

น่าเสียดายที่นั่นไม่ใช่วิธีการทำงานของระบบประเภท C # หรือ. NET ...

นี่คือสิ่งที่คุณสามารถทำได้ อย่างที่ @JohnSkeet กล่าวว่าไม่มียูนิตใน C # ดังนั้นจงสร้างมันขึ้นมาเอง!

public sealed class ThankYou {
   private ThankYou() { }
   private readonly static ThankYou bye = new ThankYou();
   public static ThankYou Bye { get { return bye; } }
}

ตอนนี้คุณสามารถใช้Func<..., ThankYou>แทนAction<...>

public ThankYou MethodWithNoResult() {
   /* do things */
   return ThankYou.Bye;
}

หรือใช้สิ่งที่สร้างโดยทีม Rx: http://msdn.microsoft.com/en-us/library/system.reactive.unit%28v=VS.103%29.aspx

คุณสามารถใช้Objectตามที่คนอื่นแนะนำได้ หรือInt32ที่เคยเห็นมาบ้าง การใช้Int32แนะนำหมายเลข "จำลอง" (ใช้0) แต่อย่างน้อยคุณไม่สามารถใส่วัตถุขนาดใหญ่และแปลกใหม่ลงในInt32ข้อมูลอ้างอิงได้ (โครงสร้างถูกปิดผนึก)

คุณยังสามารถเขียนประเภท "โมฆะ" ของคุณเองได้:

public sealed class MyVoid
{
  MyVoid()
  {
    throw new InvalidOperationException("Don't instantiate MyVoid.");
  }
}

MyVoidลำดับที่ได้รับอนุญาต (มันไม่ได้เป็นระดับคงที่) nullแต่จะไม่สามารถ ตัวสร้างอินสแตนซ์เป็นแบบส่วนตัว (และหากมีคนพยายามเรียกตัวสร้างไพรเวตนี้ผ่านการสะท้อนกลับจะมีข้อยกเว้นเกิดขึ้น)

เนื่องจากมีการนำค่า tuples มาใช้ (2017, .NET 4.7) จึงอาจเป็นเรื่องปกติที่จะใช้โครงสร้างValueTuple (0-tuple ซึ่งเป็นตัวแปรที่ไม่ใช่ตัวแปรทั่วไป) แทน a MyVoid. อินสแตนซ์มีค่าToString()ที่ส่งกลับ"()"ดังนั้นจึงดูเหมือนศูนย์ทูเพิล ในเวอร์ชันปัจจุบันของ C # คุณไม่สามารถใช้โทเค็น()ในโค้ดเพื่อรับอินสแตนซ์ได้ คุณสามารถใช้default(ValueTuple)หรือเพียงแค่default(เมื่อสามารถอนุมานประเภทจากบริบทได้) แทน

ฉันชอบความคิดของ Aleksey Bykov ข้างต้น แต่อาจทำให้ง่ายขึ้นเล็กน้อย

public sealed class Nothing {
    public static Nothing AtAll { get { return null; } }
}

เนื่องจากฉันไม่เห็นเหตุผลที่ชัดเจนว่าทำไม Nothing AtAll ไม่สามารถให้ null

แนวคิดเดียวกันนี้ (หรือแนวคิดโดย Jeppe Stig Nielsen) ยังเหมาะสำหรับการใช้งานกับคลาสที่พิมพ์

เช่นหากใช้ type เพื่ออธิบายอาร์กิวเมนต์ของโพรซีเดอร์ / ฟังก์ชันที่ส่งผ่านเป็นอาร์กิวเมนต์ของเมธอดบางอย่างเท่านั้นและตัวมันเองจะไม่ใช้อาร์กิวเมนต์ใด ๆ

(คุณยังคงต้องสร้าง dummy wrapper หรืออนุญาตตัวเลือก "Nothing" แต่ IMHO การใช้คลาสดูดีเมื่อใช้ myClass <Nothing>)

void myProcWithNoArguments(Nothing Dummy){
     myProcWithNoArguments(){
}

หรือ

void myProcWithNoArguments(Nothing Dummy=null){
    ...
}

voidแม้ว่าจะเป็นประเภท แต่จะใช้ได้เฉพาะกับประเภทการส่งคืนของวิธีการ

ไม่มีทางเลี่ยงข้อ จำกัด voidนี้ไม่เป็น

สิ่งที่ฉันทำในตอนนี้คือสร้างชนิดปิดผนึกที่กำหนดเองด้วยตัวสร้างส่วนตัว สิ่งนี้ดีกว่าการทิ้งข้อยกเว้นใน c-tor เพราะคุณไม่ต้องใช้จนกว่ารันไทม์จะพบว่าสถานการณ์ไม่ถูกต้อง จะดีกว่าการส่งคืนอินสแตนซ์แบบคงที่อย่างละเอียดเนื่องจากคุณไม่ต้องจัดสรรเลยแม้แต่ครั้งเดียว ดีกว่าการคืนค่า null แบบคงที่อย่างละเอียดเนื่องจากมีรายละเอียดน้อยกว่าในด้านการโทร สิ่งเดียวที่ผู้โทรทำได้คือให้ null

public sealed class Void {
    private Void() { }
}

public sealed class None {
    private None() { }
}