แสดงดีกว่า () + ซ่อน () หรือ SetVisible (มองเห็นบูล) หรือไม่

ดีกว่าอะไรและเพราะอะไร (จากมุมมองของการออกแบบอินเตอร์เฟส):

a) มีสองShow()และHide()ฟังก์ชั่น

b) การมีSetVisible(bool visible)ฟังก์ชั่นเดียว

แก้ไข: ตัวอย่างเช่นวัตถุบางอย่างมีสถานะการมองเห็นและฟังก์ชั่นนี้จะใช้ในการเปลี่ยนแปลง

ค) มีทั้งสามShow(), Hide(), SetVisible(bool visible)ฟังก์ชั่น

ฉันชอบSetVisible(bool visible)เพราะมันช่วยให้ฉันเขียนรหัสลูกค้าเช่นนี้:

SetVisible(DetermineIfItShouldBeVisible());

แทนที่จะต้องเขียน

if (DetermineIfItShouldBeVisible()) {
    Show();
} else {
    Hide();
}

SetVisibleวิธีนอกจากนี้ยังอาจช่วยให้สำหรับการดำเนินงานได้ง่ายขึ้น ตัวอย่างเช่นถ้าคลาสคอนกรีตเฉพาะมอบหมายวิธีการให้กับคลาสคอมโพสิตแล้วก็SetVisibleหมายถึงวิธีหนึ่งน้อยกว่าที่จะใช้

void ButtonWithALabel::SetVisible(bool visible) {
    myButton.SetVisible(visible);
    myLabel.SetVisible(visible);
}

ฉันไม่เห็นด้วยกับผู้โพสต์ทั้งหมดที่แนะนำให้ใช้หลายฟังก์ชั่นในการทำสิ่งเดียวกันเป็นสิ่งที่ดี ขณะที่สามหน้าที่แทนหนึ่งไม่อาจดูเหมือนบวมมากจำไว้ว่าการเรียนของคุณมีโอกาสที่จะจบลงด้วยฟังก์ชั่นดังกล่าวจำนวนมาก (เช่นsetEnabled, enable, disable) และทำให้วิธีการนี้จะจบลงด้วยมากอินเตอร์เฟซชั้นขนาดใหญ่ นอกจากนี้อาจเป็นไปได้ว่าคุณจะพบกับฟังก์ชั่น / คุณสมบัติ / สิ่งที่คล้ายกันในคลาสของคุณและการเพิ่มจำนวนฟังก์ชั่นจะทำให้คุณไม่เข้าใจ

ในภาษาที่รองรับคุณสมบัติเหล่านี้ควรเป็นที่ต้องการ แต่เนื่องจากทั้ง Java และ C ++ ไม่ทำฉันจึงเดาว่าเป็นจุดที่สงสัย

ฉันคิดว่าsetVisible()ควรเป็นเพราะเหตุผลเหล่านี้:

1. มันชัดเจนทันทีว่าฟังก์ชันผกผันคืออะไร ที่จะย้อนกลับsetVisible(false)ที่คุณเรียกsetVisible(true)ในขณะที่ตรงข้ามของได้อย่างง่ายดายhide()reveal()
2. มันง่ายกว่าโดยทางโปรแกรมเมื่อใดก็ตามที่คุณกำหนดสถานะที่ควรใช้ในโค้ดเช่นคุณสามารถโทรหาได้setVisible(wantToSee)มากกว่าการใช้ifคำสั่ง
3. เมื่อคุณมีฟังก์ชั่นที่คล้ายกันหลายsetX()รูปแบบ generalises รูปแบบเพื่อให้คุณสามารถมีชุดของฟังก์ชั่นที่สอดคล้องกันในขณะที่วิธีการ verbed spawns โฮสต์ของฟังก์ชั่นที่อาจเป็นเรื่องยากที่จะค้นหาถ้าคุณไม่รู้ว่าคุณกำลังมองหา ความสอดคล้องใน API ทำให้ง่ายต่อการเรียนรู้และจดจำ

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

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

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

• ความสะดวกสบายของ setVisible(bool)
  • ให้คุณหลีกเลี่ยงคำสั่ง if ที่มีเงื่อนไขเล็กน้อยและมีผลต่อการมองเห็น (เช่นsetVisible(a==b))
  • สามารถเชื่อมต่อเข้ากับเฟรมเวิร์กของ getter / setter ได้หากนั่นเป็นสิ่งที่คุณคาดหวังไว้
• ความสะดวกสบายของshow()และhide()
  • มีประโยชน์ในภาษาที่มีฟังก์ชั่นชั้นหนึ่งและการโทรกลับ (เช่นonSuccess(widget.show))
  • อ่านง่ายขึ้นด้วยการติดตามสแต็กและการทำโปรไฟล์ประสิทธิภาพเนื่องจากคุณสามารถดูได้อย่างรวดเร็วว่าโปรแกรมพยายามทำอะไร

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

ฉันจะพูดว่า "ทั้งสาม"

Show()และHide()มีแนวโน้มที่จะง่ายต่อการ grok กว่าและSetVisible(true) SetVisible(false)แต่เมื่อคุณต้องการที่จะตั้งค่าการแสดงเหตุผลมันจะดีกว่าที่จะมีวิธีการที่boolมากกว่าการสร้างรอบที่ifbool

คุณสามารถรองรับทั้งสามได้โดยไม่ต้องทำซ้ำลอจิกและโครงสร้างที่เล็กที่สุด:

void Show() {
    foo.Show();
    bar.Show();
}

void Hide() {
    foo.Hide();
    bar.Hide();
}

void SetVisible(bool visible) {
    if (visible) {
        Show();
    } else {
        Hide();
    }
}

อีกทางหนึ่งถ้าสิ่งที่คุณกำลังห่อมีSetVisibleAPI ที่มีค่ามากกว่า:

void Show() {
    SetVisible(true);
}

void Hide() {
    SetVisible(false);
}

void SetVisible(bool visible) {
    foo.SetVisible(visible);
    bar.SetVisible(visible);
}

ฉันชอบ show () และ hide () ที่จริงแล้วทุกวิธีที่ได้รับบูลีนหนึ่งสามารถเปลี่ยนได้สำหรับสองวิธีที่แสดงความตั้งใจของ API ได้ดีขึ้น ตัวอย่างเช่น Robert Martin ในโค้ดที่สะอาดแนะนำให้เลือกเมธอดที่มีอาร์กิวเมนต์เป็นศูนย์เหนือเมธอดที่มีหนึ่งอาร์กิวเมนต์

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

ฉันเชื่อว่ายิ่งวิธีมีความชัดเจนมากเท่าไรก็ยิ่งสามารถอ่านได้มากขึ้นเท่านั้นดังนั้นรหัสที่สามารถบำรุงรักษาได้ พิจารณาสองกรณีต่อไปนี้:

กรณีที่ 1:

void showCustomerData(customerId){
  Customer customer = getCustomer(CustomerId);
  customerPanel.setVisible(customer.isCustomerEnabled());
}

กรณีที่ 2:

void showCustomerData(customerId){
  Customer customer = getCustomer(CustomerId);
  //always show customer panel
  customerPanel.setVisible(true);
}

ในกรณีแรกมันชัดเจนว่าฟังก์ชั่น "setVisible" กำลังทำอะไร แต่ถ้าคุณต้องการอ่านคุณจะพูดว่า:

ตั้งค่าพาเนลลูกค้าให้มองเห็นได้หากลูกค้าเปิดใช้งานหรือตั้งเป็นซ่อนหากลูกค้าปิดใช้งาน

ในขณะที่มันเป็นคำอธิบายเพิ่มเติมที่จะพูดว่า:

• ตรวจสอบสถานะของลูกค้า:
  • หากลูกค้าถูกเปิดใช้งานให้แสดงพาเนลของลูกค้า
  • มิฉะนั้นซ่อนไว้

ซึ่งจะเปลี่ยนฟังก์ชัน "Case 1" เป็นดังต่อไปนี้:

void showCustomerData(customerId){
  Customer customer = getCustomer(CustomerId);
  if(customer.isCustomerEnabled()){
    customerPanel.Show();
  }
  else{
    customerPanel.Hide();
  }
}

มันสร้างรหัสเพิ่มเติม แต่สามารถอ่านได้มากขึ้น

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

ฉันไม่ได้บอกว่าการใช้ "setVisible" ผิดอย่างแน่นอน แต่มันก็เกิดความสับสนเมื่อคุณพยายามอ่านโค้ดที่คุณไม่ได้เขียนเมื่อเวลาผ่านไปและมันไม่สอดคล้องกับกฎ "A function ควรดำเนินการเพียงครั้งเดียว"

ฉันเชื่อว่าHide()/ Show()ทางเลือกนั้นน่าสนใจเพราะมันง่ายกว่าที่จะเข้าใจว่าเกิดอะไรขึ้นกับSetVisible(true)ในขณะที่มีฟังก์ชั่นเดียวจะดีกว่าเพราะหลีกเลี่ยงเงื่อนไขมากมาย

หากเป็นกรณีที่แล้วผมขอแนะนำให้ใช้นับเป็น input เพื่อSetVisibleให้คุณได้รับอย่างใดอย่างหนึ่งหรือSetVisible(Visibility.Visible) SetVisible(Visibility.Hidden)คุณมีฟังก์ชั่นเดียวคุณสามารถอ่านสิ่งที่กำลังดำเนินการได้ทันที

โดยใช้ Java ของการตั้งชื่อที่คุณจะต้องอาจจะหรือsetVisible(Visibility.VISIBLE)setVisible(Visibility.HIDDEN)

ฉันเห็นด้วยกับคำตอบของ Darien แต่ต้องการเพิ่มมุมมองจากมุมมองของโปรแกรมเมอร์ C #

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

ฉันไม่รู้ว่านี่คือสิ่งที่คุณคาดหวังใน Java และ C ++ หรือไม่ แต่นั่นคือสิ่งที่ฉันคาดหวังใน C # ถึงแม้ว่าใน C # จะมีมือสั้น ๆ สำหรับคุณสมบัตินี้เรียกว่า และนี่คือคำแนะนำที่ดีเกี่ยวกับวิธีใช้คุณสมบัติ ( http://msdn.microsoft.com/en-us/library/ms182181.aspx )

เมื่อพิจารณาจากมุมมองนี้แล้วอินเทอร์เฟซที่ฉันเลือกนั้นขึ้นอยู่กับว่ามีผลข้างเคียงใด ๆ (นอกเหนือจากการเปลี่ยนค่าของฟิลด์นั้น):

หากการดำเนินการมีผลข้างเคียงเช่นกำลังแสดงกล่องโต้ตอบฉันจะไปกับ "แสดง ()" และ "ซ่อน ()"

หากไม่มีผลข้างเคียงบอกว่าฉันตั้งค่าการมองเห็นของ "เครื่องมือ" และสิ่งอื่นแสดงเครื่องมือที่ขึ้นอยู่กับสถานะของมันแล้วฉันจะใช้ setVisibility หรือ setIsVisible (ฉันจะไม่เรียกมันว่า SetVisible)

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

อีกวิธีหนึ่งก็คือฉันสามารถสลับการแสดงฉลากบนแบบฟอร์มก่อนที่จะแสดงแบบฟอร์ม Ie label.getIsVisible == จริง แต่แบบฟอร์มไม่ปรากฏขึ้น

ฉันไม่ได้โทร Hide () เมื่อไม่ได้แสดงแบบฟอร์ม

ฉันขอแนะนำอินเทอร์เฟซที่ปรับเปลี่ยนเล็กน้อย:

Show();
Hide();
ToggleVisible();
ToggleVisible(bool visible);

ชื่อที่ดีขึ้น

ชื่อเมธอดเหล่านี้ช่วยให้นักพัฒนาซอฟต์แวร์ตัดสินใจว่าจะใช้วิธีใดโดยอิงตามสิ่งที่ต้องทำ ในขณะที่SetVisible(bool visible)สามารถสร้างความสับสนให้นักพัฒนาเพราะมันบ่งบอกถึงความหมายเช่นเดียวกับShow()และHide(), Toggle()หมายถึงการดำรงอยู่ของเงื่อนไขที่กำหนดดำเนินการ มันจะกลายเป็นเรื่องง่ายสำหรับนักพัฒนาเมื่อใช้แต่ละวิธี

รหัสซ้ำซ้อนลดลง

ประโยชน์ที่จะมีหลายวิธีในอินเทอร์เฟซของคุณก็คือทำให้รหัสการโทรง่ายขึ้น คุณสามารถเปิดเผยShow()และHide()แต่:

• คุณอาจต้องใช้SetVisible()วิธีการส่วนตัวเพื่อทำงานจริงเบื้องหลัง (หรือเขียนรหัสซ้ำซ้อนสำหรับShow()และHide())
• รหัสการโทรอาจมีหลายอย่างซ้ำซ้อนหาก / บล็อกเพียงเพื่อเลือกวิธีการที่จะใช้ Bloats นี้รหัสในความคิดของฉัน
• ถ้าฉันเป็นผู้บริโภคฉันน่าจะเขียนฟังก์ชั่น wrapper ของตัวเองที่ทำในสิ่งที่SetVisible()(หรือToggle()) ทำไปแล้วเพื่อหลีกเลี่ยงการขยายตัวของรหัส (ฉันเกลียดรหัสซ้ำซ้อน) ดังนั้นการทำซ้ำวิธีที่อาจมีอยู่แล้วเป็นวิธีส่วนตัวในการใช้งาน

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

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