Apakah Show () + Hide () atau SetVisible (bool terlihat) lebih baik?

Apa yang lebih baik dan mengapa? (Dari sudut pandang desain-antarmuka):

a) Untuk memiliki dua Show()dan Hide()fungsi

b) Untuk memiliki satu SetVisible(bool visible)fungsi

EDIT: Misalnya beberapa objek memiliki status visibilitas dan fungsi ini digunakan untuk mengubahnya.

c) Untuk memiliki ketiga Show(), Hide(), SetVisible(bool visible)fungsi

Saya lebih suka SetVisible(bool visible), karena memungkinkan saya menulis kode klien seperti ini:

SetVisible(DetermineIfItShouldBeVisible());

alih-alih harus menulis

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

The SetVisiblePendekatan juga memungkinkan untuk pelaksanaan lebih mudah. Misalnya, jika kelas konkret tertentu hanya mendelegasikan metode ke kelas kompositnya, maka SetVisibleberarti satu metode lebih sedikit untuk diterapkan.

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

Saya tidak setuju dengan semua poster yang menyarankan beberapa fungsi untuk melakukan hal yang sama adalah hal yang baik. Sementara tiga fungsi bukan satu mungkin tidak tampak seperti banyak mengasapi, ingat bahwa kelas Anda mungkin berakhir dengan banyak fungsi tersebut (misalnya setEnabled, enable, disable) dan dengan demikian pendekatan ini akan berakhir dengan banyak antarmuka kelas yang lebih besar. Selain itu, kemungkinan Anda akan berakhir dengan sekelompok fungsi / properti terdengar serupa / apa pun di kelas Anda dan penggandaan fungsi lebih lanjut akan mengaburkan mana yang sesuai dengan apa.

Dalam bahasa yang mendukung properti, ini harus lebih disukai tetapi karena Java maupun C ++ tidak melakukannya, saya kira itu adalah poin yang bisa diperdebatkan.

Saya pikir setVisible()harus lebih disukai karena alasan ini:

1. Segera jelas apa fungsi kebalikannya. Untuk membalikkan setVisible(false)Anda menelepon setVisible(true)sedangkan sebaliknya hide()bisa dengan mudah reveal().
2. Secara pemrograman lebih sederhana setiap kali Anda menentukan negara mana yang harus diambil dalam kode, yaitu Anda dapat menelepon setVisible(wantToSee)daripada menggunakan ifpernyataan.
3. Setelah Anda memiliki beberapa fungsi serupa, setX()formatnya akan digeneralisasi sehingga Anda dapat memiliki satu set fungsi yang konsisten sedangkan pendekatan verbed akan memunculkan sejumlah fungsi yang sulit ditemukan jika Anda tidak tahu apa yang Anda cari. Konsistensi dalam API membuatnya lebih mudah dipelajari dan diingat.

Itu tergantung pada apa yang ditunjukkan dan disembunyikan artinya dalam konteks. Pertama Anda ingin mencari tahu mana yang merupakan "jalan utama" Anda, dan fokus pada pengembangan itu:

• Alasan untuk memilih setVisible(bool)
  • Itu hanya sedikit-flip sederhana, atau objek Anda terutama memegang status
  • Objek Anda akan menghabiskan sebagian besar waktunya dalam kerangka CRUD
  • Ada banyak kode yang mudah dibagikan antara menampilkan dan menyembunyikan
• Alasan untuk memilih show()danhide()
  • Ada efek samping yang penting atau banyak logika yang dijalankan, seperti ketika objek harus memeriksa semua wadahnya untuk keadaan visibilitas mereka , atau memicu animasi transisi.
  • Apakah itu bagian dari model domain di mana mengekspresikan maksud itu penting

OK, jadi sekarang setelah Anda mengkodekan inti "standar emas" itu, Anda perlu mencari tahu apakah itu layak menambahkan metode kenyamanan tipis dalam gaya lain, untuk membuat hidup lebih mudah bagi siapa pun yang akan menggunakan objek Anda.

• Kenyamanan setVisible(bool)
  • Memungkinkan Anda menghindari pernyataan if yang memiliki kondisi sepele dan hanya memengaruhi visibilitas (mis. setVisible(a==b))
  • Dapat ditransfer ke kerangka pengambil / penyetel tertentu, jika itu sesuatu yang Anda harapkan terjadi
• Kenyamanan show()danhide()
  • Berguna dalam bahasa dengan fungsi dan panggilan balik kelas satu (mis. onSuccess(widget.show))
  • Jauh lebih mudah dibaca dengan tumpukan-jejak dan profil kinerja, karena Anda dapat dengan cepat melihat apa yang coba dilakukan oleh program

TLDR: Cari tahu mana yang paling penting, terapkan, dan kemudian tanyakan pada diri Anda apakah perlu menambahkan gaya lain sebagai metode kenyamanan yang tipis.

Saya akan mengatakan "ketiganya".

Show()dan Hide()cenderung lebih mudah grok daripada SetVisible(true)dan SetVisible(false). Namun, ketika Anda ingin mengatur visibilitas secara logis, lebih baik memiliki metode yang mengambil booldaripada membangun ifsekitar itu bool.

Anda dapat mendukung ketiganya tanpa menduplikasi logika dan boilerplate minimal:

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

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

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

Atau, jika hal-hal yang Anda bungkus memiliki SetVisibleAPI lebih -ish:

void Show() {
    SetVisible(true);
}

void Hide() {
    SetVisible(false);
}

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

Saya lebih suka show () dan hide (), pada kenyataannya, setiap metode yang menerima satu boolean dapat diubah untuk dua metode dan mengekspresikan maksud API dengan lebih baik. Sebagai contoh, Robert Martin dalam kode bersih merekomendasikan untuk memilih metode dengan argumen nol daripada metode dengan satu argumen.

Argumen penting lainnya bagi saya adalah keterbacaan, menurut saya kode yang baik dapat dibaca seperti prosa, prosa yang benar-benar aneh seperti "main_window setVisible false" daripada "main_window hide", Anda menulis atau berbicara seperti itu secara normal?, Mengapa menggunakan ini aneh konstruksi bahasa dalam program perangkat lunak, kapan mungkin menggunakan bahasa yang lebih alami?

Saya percaya bahwa semakin metode ini ekspresif, semakin mudah dibaca, dan konsekuensinya, kode akan dapat dipertahankan. Pertimbangkan dua kasus berikut:

Kasus 1:

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

Kasus 2:

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

Dalam kasus pertama, jelas apa fungsi "setVisible" lakukan, tetapi jika Anda ingin membacanya, Anda akan mengatakan:

atur panel pelanggan agar terlihat jika pelanggan diaktifkan atau setel ke tersembunyi jika pelanggan dinonaktifkan.

Sementara itu lebih deskriptif untuk mengatakan:

• periksa status pelanggan:
  • jika pelanggan diaktifkan maka tunjukkan panel pelanggan
  • jika tidak, sembunyikan

yang akan mengubah fungsi "Kasus 1" menjadi yang berikut:

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

ini menghasilkan lebih banyak kode, tetapi lebih mudah dibaca.

Kasing kedua memiliki cacat yang jelas, yaitu, Anda sudah tahu bahwa Anda ingin menampilkan panel, jadi mengapa tidak menggunakan fungsi "Tampilkan"?

Saya tidak mengatakan bahwa menggunakan "setVisible" benar-benar salah, tetapi akan membingungkan ketika Anda mencoba membaca kode yang tidak ditulis oleh Anda dari waktu ke waktu, dan itu tidak sesuai dengan aturan "Fungsi harus hanya menjalankan satu operasi" aturan.

Saya percaya bahwa Hide()/ Show()alternatif itu menarik karena lebih mudah untuk memahami apa yang terjadi daripada dengan SetVisible(true), sementara memiliki fungsi tunggal lebih disukai karena menghindari banyak persyaratan.

Jika itu yang terjadi maka saya sarankan menggunakan enumerasi sebagai input SetVisible, sehingga Anda mendapatkan salah satu SetVisible(Visibility.Visible)atau SetVisible(Visibility.Hidden). Anda memiliki satu fungsi, Anda dapat langsung membaca tindakan apa yang sedang diambil.

Menggunakan konvensi penamaan Java, Anda mungkin memiliki setVisible(Visibility.VISIBLE)atau setVisible(Visibility.HIDDEN).

Saya setuju dengan jawaban Darien, tetapi ingin menambahkan sudut pandang dari perspektif programmer C #.

Ketika saya melihat kode yang mengatakan 'setXXX' saya membacanya untuk mengatakan bahwa itu menetapkan nilai pada suatu hal, saya tidak berharap ini memiliki efek samping dalam hal itu selain mengatur nilai itu, dan saya berharap ini menjadi idempoten (Yaitu saya bisa terus menyetelnya dengan nilai yang sama dan tidak apa-apa). Ini seperti mengakses bidang. Secara umum saya juga berharap untuk melihat metode 'getXXX' bersama dengan 'setXXX'.

Saya tidak tahu apakah ini yang Anda harapkan di Java dan C ++, tapi itulah yang saya harapkan di C #, meskipun di C # ada tulisan singkat untuk properti ini. Dan inilah beberapa panduan bagus tentang cara menggunakan Properties ( http://msdn.microsoft.com/en-us/library/ms182181.aspx ).

Dengan tampilan ini, maka antarmuka yang saya pilih bergantung sepenuhnya pada apakah ada efek samping (selain mengubah nilai bidang itu):

Jika melakukan tindakan memiliki efek samping, misalnya menampilkan kotak dialog maka saya akan pergi dengan "Tampilkan ()", dan "Sembunyikan ()".

Jika tidak memiliki efek samping, katakan saya sedang mengatur visibilitas "widget" dan sesuatu yang lain membuat widget itu tergantung pada keadaan itu maka saya akan menggunakan setVisibility atau setIsVisible. (Saya tidak akan menyebutnya SetVisible).

Di C # (tidak yakin tentang Java) cukup umum untuk mengadopsi pola pengamat, di mana kerangka kerja UI akan mendengarkan perubahan objek dan secara otomatis merender ulang UI ketika properti seperti perubahan Visibilitas. Itu berarti bahwa pengaturan nilai dengan memanggil setIsVisible muncul seolah-olah ia memiliki efek samping, tetapi dalam definisi saya tidak. Kontrak widget dipenuhi dengan menetapkan nilai bidangnya yang mewakili "IsVisible".

Dengan kata lain, tidak apa-apa bagi saya untuk mengaktifkan visibilitas label pada formulir sebelum formulir ditampilkan. Yaitu label.getIsVisible == true, tetapi formulir tidak ditampilkan.

Tidak apa-apa bagi saya untuk memanggil Hide () ketika formulir tidak ditampilkan.

Saya sarankan antarmuka yang sedikit dimodifikasi:

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

Nama yang lebih baik

Nama-nama metode ini membantu pengembang untuk memutuskan metode mana yang akan digunakan berdasarkan apa yang perlu dilakukan. Sedangkan SetVisible(bool visible)dapat membingungkan pengembang karena menyampaikan makna semantik yang sama dengan Show()dan Hide(), Toggle()menyiratkan adanya suatu kondisi yang menentukan tindakan. Dengan demikian menjadi intuitif bagi pengembang kapan harus menggunakan setiap metode.

Mengurangi redundansi kode

Manfaat memiliki banyak metode di antarmuka Anda adalah menyederhanakan kode panggilan. Anda bisa saja mengekspos Show()dan Hide(), tetapi:

• Anda mungkin akan memerlukan semacam SetVisible()metode pribadi untuk melakukan pekerjaan nyata di belakang layar (atau menulis kode redundan untuk Show()dan Hide()).
• Kode panggilan mungkin memiliki banyak berlebihan jika / selain itu memblokir hanya untuk memilih metode mana yang akan digunakan. Ini menggembungkan kode menurut saya.
• Jika saya adalah konsumen, saya mungkin hanya akan menulis fungsi pembungkus saya sendiri yang melakukan apa SetVisible()(atau Toggle()) sudah dilakukan untuk menghindari kode mengasapi (saya benci kode berlebihan). Dengan demikian menduplikasi suatu metode yang mungkin sudah ada sebagai metode pribadi dalam implementasi.

Saya akan menyarankan menggunakan SetVisible(bool)jika ada hanya jika mengaktifkan visibilitas dua kali (tampilkan dan sembunyikan kembali, atau sembunyikan dan tunjukkan kembali) akan meninggalkan hal-hal dalam keadaan yang pada dasarnya sama seperti sebelum operasi dilakukan (tidak apa-apa jika menunjukkan dan menyembunyikan kembali sesuatu atau sebaliknya meninggalkan objek yang membutuhkan redraw, asalkan dapat diharapkan terjadi "secara otomatis"). Jika menyembunyikan dan menunjukkan objek tidak akan memiliki efek selain mengubah satu bit status, maka masuk akal untuk kode luar untuk memiliki beberapa metode yang menerima parameter visibilitas, dan penulisan kode tersebut akan difasilitasi oleh SetVisible.

Jika menyembunyikan dan menampilkan kembali suatu objek mungkin memiliki efek samping seperti mengubah urutan Z, tindakan seperti itu seharusnya lebih mungkin dilakukan dengan metode terpisah. Dalam kasus seperti itu, kegunaan metode luar yang menerima parameter "visibilitas" akan terbatas, sehingga akan ada sedikit keuntungan untuk memfasilitasi mereka. Lebih lanjut, suatu SetVisiblemetode akan (secara keliru) menyarankan bahwa perubahan visibilitas objek dapat dilakukan tanpa efek samping.