ข้อยกเว้น vs ชุดผลลัพธ์ว่างเปล่าเมื่ออินพุตมีความถูกต้องทางเทคนิค แต่ไม่น่าพอใจ

ฉันกำลังพัฒนาห้องสมุดที่มีไว้สำหรับเผยแพร่สู่สาธารณะ มันมีวิธีการต่าง ๆ สำหรับการทำงานกับชุดของวัตถุ - การสร้างการตรวจสอบการแบ่งและการฉายชุดในรูปแบบใหม่ ในกรณีที่มีความเกี่ยวข้องมันเป็นไลบรารีคลาส C # ที่มีส่วนขยายของสไตล์ LINQ IEnumerableที่จะเปิดตัวเป็นแพ็คเกจ NuGet

วิธีการบางอย่างในไลบรารีนี้สามารถให้พารามิเตอร์อินพุตที่ไม่น่าพอใจ ตัวอย่างเช่นในวิธี combinatoric มีวิธีการสร้างชุดnรายการทั้งหมดที่สามารถสร้างขึ้นจากชุดแหล่งที่มาของรายการm ตัวอย่างเช่นกำหนดชุด:

1, 2, 3, 4, 5

และขอให้รวมกัน 2 จะผลิต:

1, 2
1, 3
1, 4
ฯลฯ ...
5, 3
5, 4

เห็นได้ชัดว่าเป็นไปได้ที่จะขอสิ่งที่ไม่สามารถทำได้เช่นให้ชุด 3 รายการจากนั้นขอชุดค่าผสม 4 รายการพร้อมตั้งค่าตัวเลือกที่ระบุว่าสามารถใช้งานได้เพียงครั้งเดียว

ในสถานการณ์สมมตินี้แต่ละพารามิเตอร์จะถูกต้องเป็นรายบุคคล :

• การรวบรวมแหล่งที่มาไม่เป็นโมฆะและมีรายการต่างๆ
• ขนาดที่ต้องการของชุดค่าผสมเป็นจำนวนเต็มบวกที่ไม่ใช่ศูนย์
• โหมดที่ร้องขอ (ใช้แต่ละรายการเพียงครั้งเดียว) เป็นตัวเลือกที่ถูกต้อง

อย่างไรก็ตามสถานะของพารามิเตอร์เมื่อนำมารวมกันทำให้เกิดปัญหา

ในสถานการณ์นี้คุณคาดหวังว่าวิธีการจะยกเว้น (เช่น. InvalidOperationException) หรือส่งคืนคอลเลกชันที่ว่างเปล่า? ดูเหมือนว่าจะใช้ได้กับฉัน:

• คุณไม่สามารถผลิตการรวมกันของnรายการจากชุดของมรายการที่n> ม.InvalidOperationExceptionถ้าคุณได้รับอนุญาตเท่านั้นที่จะใช้แต่ละรายการครั้งเดียวดังนั้นการดำเนินการนี้ถือว่าเป็นไปไม่ได้ด้วยเหตุนี้
• ชุดของการรวมกันของขนาดnที่สามารถสร้างจากรายการmเมื่อn> mเป็นชุดว่าง ไม่สามารถสร้างชุดค่าผสมได้

อาร์กิวเมนต์สำหรับชุดที่ว่างเปล่า

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

var result = someInputSet
    .CombinationsOf(4, CombinationsGenerationMode.Distinct)
    .Select(combo => /* do some operation to a combination */)
    .ToList();

หากชุดอินพุตของคุณมีขนาดผันแปรลักษณะการทำงานของรหัสนี้ไม่แน่นอน หาก.CombinationsOf()มีข้อผิดพลาดเกิดขึ้นเมื่อsomeInputSetมีองค์ประกอบน้อยกว่า 4 ครั้งบางครั้งรหัสนี้จะล้มเหลวขณะทำงานโดยไม่มีการตรวจสอบล่วงหน้า ในตัวอย่างข้างต้นการตรวจสอบนี้เป็นเรื่องเล็กน้อย แต่ถ้าคุณเรียกมันว่าลงมาครึ่งทางของสายโซ่ยาวของ LINQ นี่อาจจะน่าเบื่อ หากมันส่งคืนชุดว่างเปล่าก็resultจะว่างเปล่าซึ่งคุณอาจจะพอใจอย่างสมบูรณ์

อาร์กิวเมนต์สำหรับข้อยกเว้น

ข้อกังวลประการที่สองของฉันคือการคืนชุดว่างอาจซ่อนปัญหา - ถ้าคุณเรียกวิธีนี้ว่าสายกลางของ LINQ และมันคืนชุดเปล่า ๆ อย่างเงียบ ๆ จากนั้นคุณอาจพบปัญหาในบางขั้นตอนในภายหลังหรือพบว่าตัวเองว่างเปล่า ชุดผลลัพธ์และอาจไม่ชัดเจนว่าเกิดขึ้นเนื่องจากคุณมีบางสิ่งบางอย่างในชุดอินพุต

คุณคาดหวังอะไรและคุณโต้แย้งอะไร

คืนชุดเปล่า

ฉันคาดหวังชุดที่ว่างเปล่าเพราะ:

มี 0 ชุดของตัวเลข 4 ตัวจากชุด 3 เมื่อฉันสามารถใช้แต่ละหมายเลขได้ครั้งเดียวเท่านั้น

เมื่อสงสัยให้ถามคนอื่น

itertools.combinationsฟังก์ชั่นตัวอย่างของคุณมีหนึ่งที่คล้ายกันมากในหลาม: มาดูกันว่ามันทำงานอย่างไร:

>>> import itertools
>>> input = [1, 2, 3, 4, 5]
>>> list(itertools.combinations(input, 2))
[(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
>>> list(itertools.combinations(input, 5))
[(1, 2, 3, 4, 5)]
>>> list(itertools.combinations(input, 6))
[]

และรู้สึกดีกับฉันอย่างสมบูรณ์ ฉันคาดหวังผลลัพธ์ที่ฉันสามารถทำซ้ำได้และได้รับหนึ่ง

แต่เห็นได้ชัดว่าถ้าคุณถามอะไรโง่ ๆ

>>> list(itertools.combinations(input, -1))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: r must be non-negative

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

ตามที่กล่าวโดย@Bakuriuในความคิดเห็นนี้ยังเป็นเหมือนกันสำหรับแบบสอบถามเหมือนSQL SELECT <columns> FROM <table> WHERE <conditions>ตราบใดที่<columns>, <table>, <conditions>จะดีขึ้นจัดรูปแบบและการอ้างอิงถึงชื่อที่มีอยู่ที่คุณสามารถสร้างชุดของเงื่อนไขที่ไม่รวมกัน InvalidConditionsErrorผลจากแบบสอบถามเพียงแค่จะให้ผลผลิตไม่มีแถวแทนการขว้างปา

ในแง่ของคนธรรมดา:

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

ฉันเห็นด้วยกับคำตอบของ Ewanแต่ต้องการเพิ่มเหตุผลเฉพาะ

คุณกำลังเผชิญกับการดำเนินการทางคณิตศาสตร์ดังนั้นจึงอาจเป็นคำแนะนำที่ดีที่จะใช้นิยามทางคณิตศาสตร์ที่เหมือนกัน จากมุมมองทางคณิตศาสตร์จำนวนr -sets ของn- set (เช่นnCr ) ถูกกำหนดไว้อย่างดีสำหรับทุก r> n> = 0 มันเป็นศูนย์ ดังนั้นการคืนชุดว่างจะเป็นกรณีที่คาดหวังจากมุมมองทางคณิตศาสตร์

ฉันพบวิธีที่ดีในการพิจารณาว่าจะใช้ข้อยกเว้นคือการจินตนาการว่าผู้คนมีส่วนร่วมในการทำธุรกรรม

การดึงเนื้อหาของไฟล์เป็นตัวอย่าง:

1. โปรดดึงเนื้อหาของไฟล์ "ไม่อยู่"

   "นี่คือเนื้อหา: ชุดอักขระว่าง"

   ข "เอ่อมีปัญหาไฟล์นั้นไม่มีอยู่ฉันไม่รู้จะทำยังไง!"

2. โปรดดึงเนื้อหาของไฟล์ "มีอยู่ แต่ว่างเปล่า"

   "นี่คือเนื้อหา: ชุดอักขระว่าง"

   ข "เอ่อมีปัญหาไม่มีอะไรในไฟล์นี้ฉันไม่รู้จะทำยังไง!"

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

ดังนั้นการใช้วิธีการเดียวกันกับตัวอย่างของคุณ:

3. กรุณาให้ฉันทั้งหมดรวม 4 รายการสำหรับ {1, 2, 3}

   ไม่มีเลยนี่เป็นเซตว่างเปล่า

   ข มีปัญหาฉันไม่รู้จะทำอย่างไร

อีกครั้ง "มีปัญหา" จะสมเหตุสมผลถ้าnullมีการนำเสนอเช่นชุดของรายการ แต่ "นี่เป็นชุดที่ว่างเปล่า" ดูเหมือนว่าการตอบสนองที่เหมาะสมกับการร้องขอข้างต้น

หากส่งคืนค่าว่างจะทำให้เกิดปัญหา (เช่นไฟล์ที่ขาดหายไปกnull) ดังนั้นโดยทั่วไปควรใช้ข้อยกเว้นแทน (เว้นแต่ว่าภาษาที่คุณเลือกจะรองรับoption/maybeประเภท มิฉะนั้นการคืนค่าเปล่าจะทำให้ต้นทุนลดลงและเป็นไปตามหลักการที่น่าประหลาดใจน้อยที่สุด

เนื่องจากมันมีไว้สำหรับไลบรารีวัตถุประสงค์ทั่วไปสัญชาตญาณของฉันก็คือให้ผู้ใช้เลือกได้

เหมือนที่เรามีParse()และTryParse()มีให้เราเราสามารถมีตัวเลือกที่เราใช้ขึ้นอยู่กับสิ่งที่เราต้องการออกจากฟังก์ชั่น คุณจะใช้เวลาน้อยลงในการเขียนและบำรุงรักษา wrapper ฟังก์ชันเพื่อให้เกิดข้อยกเว้นมากกว่าการพิจารณาเลือกรุ่นเดียวของฟังก์ชั่น

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

ดังนั้นฉันจะลงคะแนนให้ ArgumentException โดยให้ข้อมูลที่จำเป็นสำหรับผู้ใช้เพื่อทำความเข้าใจกับสิ่งที่ผิดพลาด

เป็นตัวอย่างให้ตรวจสอบ public static TSource ElementAt<TSource>(this IEnumerable<TSource>, Int32)ฟังก์ชั่นใน Linq ซึ่งจะโยน ArgumentOutOfRangeException หากดัชนีน้อยกว่า 0 หรือมากกว่าหรือเท่ากับจำนวนองค์ประกอบในแหล่งที่มา ดังนั้นดัชนีจะถูกตรวจสอบเกี่ยวกับการนับที่จัดทำโดยผู้โทร

คุณควรทำอย่างใดอย่างหนึ่งต่อไปนี้ (แม้ว่าจะยังคงมีการทิ้งปัญหาพื้นฐานอย่างต่อเนื่องเช่นจำนวนชุดค่าลบ):

1. จัดเตรียมการนำไปใช้สองแบบชุดหนึ่งที่ส่งคืนชุดว่างเมื่ออินพุตเข้าด้วยกันนั้นไร้ความหมายและอีกชุดหนึ่งที่ส่งออกมา ลองเรียกพวกเขาและCombinationsOf CombinationsOfWithInputCheckหรืออะไรก็ได้ที่คุณชอบ CombinationsOfAllowInconsistentParametersคุณสามารถย้อนกลับนี้เพื่อให้การป้อนข้อมูลการตรวจสอบอย่างใดอย่างหนึ่งเป็นชื่อที่สั้นและรายการหนึ่งคือ

2. สำหรับวิธีการของ Linq ให้คืนค่าว่างIEnumerableในหลักฐานที่คุณได้กำหนดไว้ จากนั้นเพิ่มวิธี Linq เหล่านี้ในห้องสมุดของคุณ:

   public static class EnumerableExtensions {
      public static IEnumerable<T> ThrowIfEmpty<T>(this IEnumerable<T> input) {
         return input.IfEmpty<T>(() => {
            throw new InvalidOperationException("An enumerable was unexpectedly empty");
         });
      }
   
      public static IEnumerable<T> IfEmpty<T>(
         this IEnumerable<T> input,
         Action callbackIfEmpty
      ) {
         var enumerator = input.GetEnumerator();
         if (!enumerator.MoveNext()) {
            // Safe because if this throws, we'll never run the return statement below
            callbackIfEmpty();
         }
         return EnumeratePrimedEnumerator(enumerator);
      }
   
      private static IEnumerable<T> EnumeratePrimedEnumerator<T>(
         IEnumerator<T> primedEnumerator
      ) {
         yield return primedEnumerator.Current;
         while (primedEnumerator.MoveNext()) {
            yield return primedEnumerator.Current;
         }
      }
   }

   ในที่สุดใช้สิ่งที่ชอบโดยทำดังนี้

   var result = someInputSet
      .CombinationsOf(4, CombinationsGenerationMode.Distinct)
      .ThrowIfEmpty()
      .Select(combo => /* do some operation to a combination */)
      .ToList();

   หรือเช่นนี้

   var result = someInputSet
      .CombinationsOf(4, CombinationsGenerationMode.Distinct)
      .IfEmpty(() => _log.Warning(
         $@"Unexpectedly received no results when creating combinations for {
            nameof(someInputSet)}"
      ))
      .Select(combo => /* do some operation to a combination */)
      .ToList();

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

   อย่างไรก็ตามโปรดทราบว่าแน่นอนว่าต้องระบุอย่างน้อยรายการแรกเพื่อตรวจสอบว่ามีรายการใด ๆ หรือไม่ นี่คืออุปสรรคที่อาจเกิดขึ้นที่ผมคิดว่าน่าจะบรรเทาลงโดยส่วนใหญ่เป็นความจริงที่ว่าผู้ชมใด ๆ ในอนาคตสามารถเหตุผลค่อนข้างง่ายว่าThrowIfEmptyวิธีการที่มีการระบุอย่างน้อยหนึ่งรายการดังนั้นควรไม่ต้องแปลกใจโดยการทำเช่นนั้น แต่คุณไม่เคยรู้ ThrowIfEmptyByEnumeratingAndReEmittingFirstItemคุณอาจจะทำเรื่องนี้ให้ชัดเจนมากขึ้น แต่นั่นดูเหมือนว่าจะเป็นการ overkill ที่ใหญ่โต

ฉันคิดว่า # 2 ค่อนข้างดีเยี่ยม! ตอนนี้กำลังอยู่ในการเรียกรหัสและผู้อ่านคนต่อไปของรหัสจะเข้าใจสิ่งที่มันกำลังทำอยู่และไม่ต้องจัดการกับข้อยกเว้นที่ไม่คาดคิด

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

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

.CombinationsOf(4, CombinationsGenerationMode.Distinct, Options.AllowEmptySets)

มีสองวิธีในการตัดสินใจว่าไม่มีคำตอบที่ชัดเจนหรือไม่:

• เขียนรหัสสมมติตัวเลือกแรกจากนั้นตัวเลือกอื่น พิจารณาว่าอันไหนดีที่สุดในการปฏิบัติ

• เพิ่มพารามิเตอร์บูลีน "เข้มงวด" เพื่อระบุว่าคุณต้องการให้พารามิเตอร์ตรวจสอบอย่างเข้มงวดหรือไม่ ตัวอย่างเช่น Java SimpleDateFormatมีsetLenientวิธีการแยกวิเคราะห์อินพุตที่ไม่ตรงกับรูปแบบทั้งหมด แน่นอนคุณต้องตัดสินใจว่าค่าเริ่มต้นคืออะไร

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

หากคุณรู้สึกว่าผู้ใช้บางคนอาจต้องการบังคับให้ส่งคืนที่ไม่มีข้อมูลให้พวกเขามีวิธีที่จะถามถึงพฤติกรรมนั้นแทนที่จะบังคับใช้กับทุกคน ตัวอย่างเช่นคุณอาจ:

• ทำให้เป็นตัวเลือกการกำหนดค่าบนวัตถุใด ๆ ที่กำลังทำการกระทำสำหรับผู้ใช้
• ทำให้เป็นค่าสถานะที่ผู้ใช้สามารถเลือกให้ส่งผ่านฟังก์ชันได้
• ให้AssertNonemptyเช็คที่พวกเขาสามารถใส่ไว้ในโซ่ของพวกเขา
• ทำให้ทั้งสองฟังก์ชั่นหนึ่งฟังก์ชั่นที่ไม่ว่างเปล่าและอีกฟังก์ชั่นหนึ่งที่ไม่รองรับ

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

• หากคุณกลับมาInfในห้องสมุด Python ผู้คนจะโจมตีคุณเนื่องจากการซ่อนข้อผิดพลาด
• หากคุณเกิดข้อผิดพลาดในไลบรารี Matlab ผู้คนจะโจมตีคุณเนื่องจากไม่สามารถประมวลผลข้อมูลด้วยค่าที่หายไป

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

โซลูชันที่ให้ผู้ใช้เลือก (เช่นการเพิ่มพารามิเตอร์ "เข้มงวด") ไม่ชัดเจนเนื่องจากพวกเขาแทนที่คำถามเดิมด้วยคำถามใหม่ที่เทียบเท่า: "ค่าใดstrictควรเป็นค่าเริ่มต้น"

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

กฎชุดทั่วไป:

• Set.Foreach (กริยา); // คืนค่าเป็นจริงเสมอสำหรับเซตว่าง
• Set.Exists (กริยา); // ส่งคืนค่า false สำหรับชุดว่างเสมอ

คำถามของคุณลึกซึ้งมาก:

• อาจเป็นได้ว่าอินพุตของฟังก์ชันของคุณต้องเคารพสัญญา :ในกรณีนั้นอินพุตที่ไม่ถูกต้องใด ๆ ควรเพิ่มข้อยกเว้นนั่นก็คือฟังก์ชั่นไม่ทำงานภายใต้พารามิเตอร์ปกติ

• อาจเป็นได้ว่าอินพุตของฟังก์ชั่นของคุณจะต้องทำงานเหมือนชุดดังนั้นจึงควรกลับชุดที่ว่างเปล่าได้

ตอนนี้ถ้าฉันอยู่ในคุณฉันจะไปทาง "ชุด" แต่ด้วย "BUT" ขนาดใหญ่

สมมติว่าคุณมีคอลเลกชันที่ "โดย hypotesis" ควรมีนักเรียนหญิงเท่านั้น:

class FemaleClass{

    FemaleStudent GetAnyFemale(){
        var femaleSet= mySet.Select( x=> x.IsFemale());
        if(femaleSet.IsEmpty())
            throw new Exception("No female students");
        else
            return femaleSet.Any();
    }
}

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

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

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

ในกรณีของคุณมันเป็นความคิดที่ดีที่จะทำ:

List SomeMethod( Set someInputSet){
    var result = someInputSet
        .CombinationsOf(4, CombinationsGenerationMode.Distinct)
        .Select(combo => /* do some operation to a combination */)
        .ToList();

    // the only information here is that set is empty => there are no combinations

    // BEWARE! if 0 here it may be invalid input, but also a empty set
    if(result.Count == 0)  //Add: "&&someInputSet.NotEmpty()"

    // we go a step further, our API require combinations, so
    // this method cannot satisfy the API request, then we throw.
         throw new Exception("you requsted impossible combinations");

    return result;
}

แต่มันเป็นไปไม่ได้จริงๆความคิดที่ดีตอนนี้เรามีรัฐที่ไม่ถูกต้องที่สามารถ occurr ที่รันไทม์ในช่วงเวลาที่สุ่ม แต่ที่เป็นนัยในปัญหาที่เกิดขึ้นดังนั้นเราจึงไม่สามารถเอามันแน่ใจว่าเราสามารถย้ายยกเว้นภายในบางวิธียูทิลิตี้ (มันเป็นสิ่ง รหัสเดียวกันย้ายในสถานที่ที่แตกต่างกัน) แต่ที่ผิดปกติและพื้นสิ่งที่ดีที่สุดที่คุณสามารถทำได้คือการติดกับกฎระเบียบของชุดปกติ

Infact เพิ่มความซับซ้อนใหม่เพียงเพื่อแสดงว่าคุณสามารถเขียนวิธีการสืบค้น linq ดูเหมือนจะไม่คุ้มค่าสำหรับปัญหาของคุณฉันค่อนข้างแน่ใจว่าถ้า OP สามารถบอกเราเพิ่มเติมเกี่ยวกับโดเมนของมันได้เราอาจจะหาจุดที่ต้องการยกเว้น เป็นไปได้ว่าปัญหาไม่จำเป็นต้องมีข้อยกเว้นใด ๆ เลย)