หลักการของความประหลาดใจน้อยที่สุด (POLA) และส่วนต่อประสาน

ไตรมาสที่ดีของศตวรรษที่ผ่านมาเมื่อฉันเรียนรู้ C ++ ฉันได้รับการสอนว่าอินเตอร์เฟสควรจะให้อภัยและเท่าที่เป็นไปได้ไม่สนใจเกี่ยวกับลำดับที่วิธีการนั้นถูกเรียกเนื่องจากผู้บริโภคอาจไม่สามารถเข้าถึงแหล่งข้อมูลหรือเอกสารแทน นี้.

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

ชัดเจนเหมือนโคลน

พิจารณาอินเทอร์เฟซด้วยวิธีการเหล่านี้ (สำหรับการสร้างไฟล์ข้อมูล):

OpenFile
SetHeaderString
WriteDataLine
SetTrailerString
CloseFile

ตอนนี้คุณสามารถแน่นอนเพียงไปถึงเหล่านี้ในการสั่งซื้อ แต่บอกว่าคุณไม่สนใจเกี่ยวกับชื่อไฟล์ (คิดว่าa.out) AddDataLineหรือสิ่งที่หัวและสตริงรถพ่วงถูกรวมคุณสามารถเพียงแค่โทร

ตัวอย่างที่มีความรุนแรงน้อยกว่าอาจมองข้ามส่วนหัวและส่วนท้าย

อาจมีอีกอย่างหนึ่งอาจตั้งค่าสตริงส่วนหัวและส่วนท้ายก่อนที่จะเปิดไฟล์

นี่เป็นหลักการของการออกแบบส่วนต่อประสานที่ได้รับการยอมรับหรือเป็นวิธี POLA ก่อนที่จะได้รับชื่อหรือไม่?

NB ไม่จมลงในส่วนย่อยของอินเทอร์เฟซนี้มันเป็นเพียงตัวอย่างเพื่อประโยชน์ของคำถามนี้

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

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

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

พิจารณา API ทางเลือกที่การดำเนินการ IO แยกจากการดำเนินการข้อมูล และตำแหน่งที่ API นั้น 'เป็นเจ้าของ' การสั่งซื้อ:

ContentBuilder

SetHeader( ... )
AddLine( ... )
SetTrailer ( ... )

FileWriter

Open(filename) 
Write(content) throws InvalidContentException
Close()

ด้วยการแยกข้างต้นContentBuilderไม่จำเป็นต้อง "ทำ" สิ่งใดนอกจากการจัดเก็บบรรทัด / ส่วนหัว / ส่วนท้าย (อาจเป็นContentBuilder.Serialize()วิธีการที่ทราบลำดับ) โดยทำตามหลักการของแข็งอื่น ๆ มันไม่สำคัญว่าคุณจะตั้งหัวหรือรถพ่วงก่อนหรือหลังเส้นเพิ่มเพราะไม่มีอะไรในจะถูกเขียนไปยังแฟ้มจริงจนกว่าจะผ่านมันไป ContentBuilderFileWriter.Write

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

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

สิ่งนี้ไม่เพียงเกี่ยวกับ POLA แต่ยังเกี่ยวกับการป้องกันสถานะที่ไม่ถูกต้องว่าเป็นแหล่งที่มาของข้อบกพร่อง

มาดูกันว่าเราสามารถให้ข้อ จำกัด บางประการกับตัวอย่างของคุณได้อย่างไรโดยไม่ต้องมีการนำไปใช้อย่างเป็นรูปธรรม:

ขั้นตอนแรก: ไม่อนุญาตให้เรียกสิ่งใด ๆ ก่อนที่จะเปิดไฟล์

CreateDataFileInterface
  + OpenFile(filename : string) : DataFileInterface

DataFileInterface
  + SetHeaderString(header : string) : void
  + WriteDataLine(data : string) : void
  + SetTrailerString(trailer : string) : void
  + Close() : void

ตอนนี้มันควรจะชัดเจนว่าCreateDataFileInterface.OpenFileจะต้องเรียกเพื่อดึงDataFileInterfaceอินสแตนซ์ที่สามารถเขียนข้อมูลจริง

ขั้นตอนที่สอง: ตรวจสอบว่าได้ตั้งค่าส่วนหัวและตัวอย่างเสมอ

CreateDataFileInterface
  + OpenFile(filename : string, header: string, trailer : string) : DataFileInterface

DataFileInterface
  + WriteDataLine(data : string) : void
  + Close() : void

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

ในการตอบกลับความคิดเห็น:

ฉันชอบแยกอินเทอร์เฟซ แต่ฉันอยากจะคิดว่าข้อเสนอแนะของคุณเกี่ยวกับการบังคับใช้ (เช่น WriteTrailerAndClose ()) กำลังตรวจสอบว่ามีการละเมิด SRP (นี่คือสิ่งที่ฉันต่อสู้มาหลายครั้ง แต่ข้อเสนอแนะของคุณน่าจะเป็นตัวอย่างที่เป็นไปได้) คุณจะตอบอย่างไร

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

CreateDataFileInterface
  + OpenFile(filename : string, header : string) : IncompleteDataFileInterface

IncompleteDataFileInterface
  + WriteDataLine(data : string) : void
  + FinalizeWithTrailer(trailer : string) : CompleteDataFileInterface

CompleteDataFileInterface
  + Close()

ฉันจะไม่ทำมันสำหรับตัวอย่างนี้จริง ๆ แต่มันแสดงให้เห็นว่าจะส่งผ่านเทคนิคได้อย่างไร

โดยวิธีการที่ฉันคิดว่าวิธีการที่จริงจะต้องเรียกว่าในคำสั่งนี้เช่นการเขียนตามลำดับหลายบรรทัด หากไม่ต้องการสิ่งนี้ฉันจะชอบผู้สร้างเสมอตามที่ Ben Cottrelแนะนำ