ฉันควรโยนข้อยกเว้นในกรณีที่มีค่าที่มีความหมายนอกช่วงหรือจัดการกับตัวเองหรือไม่?

ฉันได้เขียน struct ที่แสดงถึงพิกัดละติจูด / ลองจิจูด ค่าของพวกเขามีตั้งแต่ -180 ถึง 180 สำหรับ longtitudes และ 90 ถึง -90 สำหรับ lattitudes

หากผู้ใช้งานของ struct นั้นให้คุณค่าแก่ฉันนอกช่วงนั้นฉันมี 2 ตัวเลือก:

1. โยนข้อยกเว้น (อยู่นอกช่วง)
2. แปลงค่าเป็นข้อ จำกัด

เนื่องจากพิกัด -185 มีความหมาย (สามารถแปลงได้อย่างง่ายดายมากถึง +175 เหมือนกับพิกัดเชิงขั้ว) ฉันจึงยอมรับและแปลงได้

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

แก้ไข: ฉันรู้ถึงความแตกต่างระหว่าง lat / lng และพิกัด แต่ฉันต้องการทำให้มันง่ายขึ้นสำหรับการสนทนาที่ง่ายขึ้น - มันไม่ใช่ความคิดที่เจิดจ้าที่สุด

หากแก่นแท้ของคำถามของคุณคือสิ่งนี้ ...

หากรหัสลูกค้าบางรายการผ่านการโต้แย้งที่มีค่าไม่ถูกต้องสำหรับสิ่งที่โครงสร้างข้อมูลของฉันกำลังสร้างแบบจำลองฉันควรปฏิเสธค่าหรือแปลงเป็นสิ่งที่สมเหตุสมผลหรือไม่

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

คำถามคือคุณกำลังเผชิญกับกรณีนั้นจริงหรือไม่

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

• หากโครงสร้างข้อมูลของคุณเป็นแบบจำลองการประสานงาน Web Mercator อย่างชัดเจน (ตามคำถามในรูปแบบเริ่มต้น) ดังนั้นควรปฏิบัติตามข้อกำหนดที่ระบุไว้ในข้อกำหนด (ซึ่งฉันไม่รู้ดังนั้นฉันจะไม่พูดอะไรเลย) . หากข้อกำหนดของสิ่งที่คุณกำลังสร้างโมเดลบอกว่าค่าบางอย่างไม่ถูกต้องให้ปฏิเสธ ถ้ามันบอกว่าพวกเขาสามารถตีความได้ว่าเป็นสิ่งที่สมเหตุสมผล

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

มันขึ้นอยู่มาก แต่คุณควรตัดสินใจที่จะทำบางสิ่งบางอย่างและเอกสารนั้น

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

ในกรณีนี้ฉันสามารถดูข้อโต้แย้งด้วยวิธีใดก็ได้ หากมีคนเดินทาง +10 องศาจาก 175 องศาพวกเขาควรจะอยู่ที่ -175 หากคุณทำให้การป้อนข้อมูลของผู้ใช้เป็นปกติและให้ถือว่า 185 เท่ากับ -175 ดังนั้นรหัสลูกค้าจะไม่สามารถทำสิ่งผิดพลาดได้เมื่อมันเพิ่ม 10 องศา มันมักจะมีผลที่ถูกต้อง หากคุณปฏิบัติต่อ 185 เป็นข้อผิดพลาดคุณบังคับให้ทุกกรณีที่รหัสลูกค้าเพิ่มองศาสัมพันธ์เพื่อวางในตรรกะการทำให้เป็นมาตรฐาน (หรืออย่างน้อยอย่าลืมเรียกขั้นตอนการทำให้ปกติของคุณ) คุณจะทำให้ข้อบกพร่อง (แม้ว่าหวังว่าจะจับคนที่จะถูกบีบอย่างรวดเร็ว) แต่ถ้าหมายเลขลองจิจูดนั้นถูกป้อนโดยผู้ใช้เขียนตัวอักษรในโปรแกรมหรือคำนวณผ่านขั้นตอนบางอย่างที่ตั้งใจจะอยู่ใน [-180, 180) ดังนั้นค่าที่อยู่นอกช่วงนั้นก็น่าจะบ่งบอกถึงข้อผิดพลาดได้ดังนั้น "เป็นประโยชน์ "การแปลงไฟล์อาจซ่อนปัญหา

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

ถ้ามันไม่สำคัญสำหรับคุณที่จะเลือกโซลูชันเดียวคุณสามารถให้ผู้ใช้ตัดสินใจได้

เนื่องจาก struct ของคุณเป็นวัตถุค่าแบบอ่านอย่างเดียวและสร้างโดยเมธอด / คอนสตรัคเตอร์คุณสามารถจัดเตรียมโอเวอร์โหลดสองตัวตามตัวเลือกที่ผู้ใช้มี:

• โยนข้อยกเว้น (อยู่นอกช่วง)
• แปลงค่าเป็นข้อ จำกัด

อย่าปล่อยให้ผู้ใช้มีโครงสร้างที่ไม่ถูกต้องส่งผ่านไปยังวิธีอื่นของคุณทำให้ถูกต้องในการสร้าง

แก้ไข: ตามความคิดเห็นฉันคิดว่าคุณใช้ c #

ขึ้นอยู่กับว่าอินพุตนั้นมาจากผู้ใช้โดยตรงผ่าน UI บางอย่างหรือมาจากระบบ

ป้อนข้อมูลผ่าน UI

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

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

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

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

ป้อนข้อมูลผ่าน API

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

คุณควรโยนข้อยกเว้น

ในตัวอย่างที่คุณให้ส่ง 185 และแปลงให้เป็น -175 จากนั้นมันอาจจะมีประโยชน์ในบางกรณีเพื่อให้ฟังก์ชันการทำงานนั้น แต่ถ้าผู้โทรส่ง 1 ล้าน พวกเขาหมายถึงการแปลงที่จริง ๆ ? ดูเหมือนว่ามีข้อผิดพลาดมากกว่า ดังนั้นหากคุณจำเป็นต้องโยนข้อยกเว้นสำหรับ 1,000,000 แต่ไม่ใช่สำหรับ 185 คุณจะต้องตัดสินใจเกี่ยวกับเกณฑ์ที่กำหนดเองสำหรับการโยนข้อยกเว้น เกณฑ์นั้นกำลังจะไปพบคุณในบางครั้งเนื่องจากแอปพลิเคชันบางตัวกำลังส่งค่ารอบ ๆ เกณฑ์

ดีกว่าที่จะโยนข้อยกเว้นสำหรับค่าที่อยู่นอกช่วง

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

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

BTW, ผมรักรุ่นข้อผิดพลาดที่เสนอโดยโจดัฟฟี่ที่นี่

เริ่มต้นควรจะโยนข้อยกเว้น นอกจากนี้คุณยังสามารถอนุญาตให้มีตัวเลือกเช่นstrict=falseและทำการบังคับตามธงซึ่งแน่นอนว่าstrict=trueเป็นค่าเริ่มต้น นี่เป็นเรื่องธรรมดา:

• Java DateFormatสนับสนุนผ่อนปรน
• ตัวแยกวิเคราะห์ JSON ของ Gson ยังสนับสนุนโหมดผ่อนปรน
• เป็นต้น

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

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