Daha iyi Show () + Hide () veya SetVisible (bool görünür)?

Hangisi daha iyi ve neden? (Arayüz tasarımı açısından):

a) İkisine Show()ve Hide()fonksiyonuna sahip olmak

b) Bir SetVisible(bool visible)işleve sahip olmak

EDIT: Örneğin, bazı nesnelerin görünürlük durumu vardır ve bu fonksiyonlar onu değiştirmek için kullanılır.

c) her üç sahip olmak Show(), Hide(), SetVisible(bool visible)işlevlerini

Tercih ediyorum SetVisible(bool visible), çünkü müşteri kodunu şöyle yazmamı sağlıyor:

SetVisible(DetermineIfItShouldBeVisible());

yazmak zorunda kalmak yerine

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

SetVisibleYaklaşım aynı zamanda daha kolay uygulanması için izin verebilir. Örneğin, belirli bir somut sınıf basitçe metodu kompozit sınıflarına devrederse, SetVisibleuygulanacak daha az bir yöntem demektir.

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

Aynı işi yapmak için birden fazla işlevi öneren tüm posterlere katılmıyorum. Bir yerine üç fonksiyonları çok kabartmak gibi görünmeyebilir iken, sınıf birçok tür fonksiyonları (örn ile bitirmek muhtemel olduğunu unutmayın setEnabled, enable, disablebir ile sona erecek) ve böylece bu yaklaşımın çok daha büyük sınıf arayüzüne. Dahası, sınıfınızdaki her ne olursa olsun, benzer iskan fonksiyonlarından / özelliklerinden bir demet ile sonlanmanız ve fonksiyonların çarpılması hangisinin neyle gittiğini daha da gizleyecektir.

Özellikleri destekleyen dillerde, bunlar tercih edilmelidir, ancak ne Java ne de C ++ 'ın yapmamasından dolayı, bunun bir tartışma noktası olduğunu düşünüyorum.

setVisible()Bu nedenlerden dolayı tercih edilmesi gerektiğini düşünüyorum :

1. Ters fonksiyonun ne olduğu hemen bellidir. Sizi geri setVisible(false)aramak setVisible(true)için hide()kolayca zıttı olabilirken arayın reveal().
2. Hangi durumda kod alması gerektiğine karar verdiğinizde programa göre basittir, yani setVisible(wantToSee)bir ififade kullanmak yerine çağırabilirsiniz .
3. Birden çok benzer işleve sahip olduğunuzda, setX()biçim genelleşir, böylece bir dizi tutarlı işleve sahip olabilirsiniz, oysa verhed yaklaşımı, aradığınızı bilmiyorsanız, bulunması zor olan bir dizi işlev ortaya çıkarır. API'lardaki tutarlılık, öğrenmelerini ve hatırlamalarını önemli ölçüde kolaylaştırır.

Gösterme ve gizlemenin bağlamda ne anlama geldiğine bağlıdır . İlk önce hangisinin "ana yolunuz" olduğunu bulmak ve bunu geliştirmeye odaklanmak istiyorsunuz:

• Seçme nedenleri setVisible(bool)
  • Bu sadece basit bir bit çevirmedir veya nesneniz temelde tutuluyor
  • Hedefiniz zamanının çoğunu bir CRUD çerçevesinde geçirecek
  • Gösterme ve gizleme arasında kolayca paylaşılan bir çok kod vardır.
• Seçme nedenleri show()vehide()
  • Nesnenin tüm konteynırlarını görünürlük durumları için kontrol etmesi gerektiği veya bir geçiş animasyonunu tetiklediği zaman gibi önemli bir yan etki veya çok sayıda mantık çalıştırılıyor .
  • Niyeti ifade etmenin önemli olduğu bir etki alanı modelinin parçası mı?

Tamam, şimdi "altın standart" çekirdeğini kodladınız, nesneyi kullanacak hayatı kolaylaştırmak için diğer stile ince bir kolaylık yöntemi eklemenin değip değmeyeceğini bulmanız gerekiyor.

• Kolaylık setVisible(bool)
  • Önemsiz koşulları olan ve yalnızca görünürlüğü etkileyen if-ifadelerinden kaçınmanızı sağlar (ör. setVisible(a==b))
  • Gerçekleşmesini beklediğiniz bir şeyse, belirli alıcı / ayarlayıcı çerçevelerine kablolanabilir
• Kolaylık show()vehide()
  • Birinci sınıf fonksiyonları ve geri aramaları olan bir dilde faydalıdır (ör. onSuccess(widget.show))
  • Programın ne yapmaya çalıştığını hızlı bir şekilde görebildiğiniz için yığın izleri ve performans profili ile okumak çok daha kolay

TLDR: Hangisinin en önemli olduğunu bulun, uygulayın ve sonra kendinize diğer stili ince uygunluk yöntemleri olarak eklemeye değip değmediğini sorun.

Ben "üçü" derdim.

Show()ve Hide()daha grok kolay olma eğilimindedir SetVisible(true)ve SetVisible(false). Ancak, görünürlüğü mantıklı bir şekilde ayarlamak istediğinizde, bunun etrafında boolbir inşa etmekten ziyade bir yönteme sahip olmak daha iyidir .ifbool

Üçünü de mantığı ve en az boyler plakasını çoğaltmadan destekleyebilirsiniz:

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

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

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

Alternatif olarak, sarmakta olduğunuz şeyler daha SetVisible-ish bir API’ye sahipse:

void Show() {
    SetVisible(true);
}

void Hide() {
    SetVisible(false);
}

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

Show () ve hide () 'ı tercih ediyorum, aslında, bir boolean alan her yöntem, API'nin amacını daha iyi ifade eden iki yöntem için değiştirilebilir. Örneğin, temiz koddaki Robert Martin, bir argüman olan yöntemler yerine sıfır argümanlarla tercih edilen yöntemleri önerir.

Benim için bir başka önemli argüman da okunabilirlik, bence iyi kod, nesir gibi okunabilir, "garip bir şey" main_window set "yerine" main_window setVisible false "gibi bir şey. Yazılım programlarında dil inşası mükemmel bir şekilde mümkün olduğunda daha doğal bir dil kullanın.

Yöntemin ne kadar etkileyici, daha okunaklı ve sonuç olarak kodun korunabileceğine inanıyorum. Aşağıdaki iki durumu göz önünde bulundurun:

Dava 1:

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

Durum 2:

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

İlk durumda, "setVisible" işlevinin ne yaptığı açıktır, ancak okumak istiyorsanız şunu söyleyiniz:

Müşteri panelini müşteri etkinse görünür olarak veya müşteri devre dışıysa gizlenmiş olarak ayarlayın.

Söylemek daha açıklayıcı olsa da:

• Müşterinin durumunu kontrol et:
  • müşteri etkinse müşterinin panelini göster
  • Aksi takdirde, gizleyin

"Case 1" işlevini aşağıdaki gibi değiştirecek:

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

daha fazla kod üretir, ancak daha okunaklıdır.

İkinci durumun, paneli göstermek istediğinizi zaten bildiğiniz için açık bir kusuru var, öyleyse neden "Göster" işlevini kullanmıyorsunuz?

"SetVisible" kullanmanın kesinlikle yanlış olduğunu söylemiyorum, ancak zaman içinde sizin tarafınızdan yazılmayan kodu okumaya çalıştığınızda kafa karıştırıcı olur ve "Bir fonksiyon sadece bir işlem yapmalı" kuralına uymaz.

Hide()/ Show()Alternatifin çekici olduğuna inanıyorum, çünkü olanları anlamaktan daha kolay; SetVisible(true)tek bir fonksiyona sahip olmak tercih edilebiliyor, çünkü birçok şartlı durumdan kaçınıyor.

Bu durumda, giriş olarak bir numaralandırma kullanmanızı öneririm SetVisible, bu yüzden ya SetVisible(Visibility.Visible)da elde edersiniz SetVisible(Visibility.Hidden). Tek bir işleve sahipseniz, hangi işlemin yapıldığını anında okuyabilirsiniz.

Java'nın adlandırma kurallarına kullanarak, belki olurdu setVisible(Visibility.VISIBLE)ya setVisible(Visibility.HIDDEN).

Darien'in cevabına katılıyorum, ancak C # programcıları bakış açısından bir bakış açısı eklemek istedim.

'SetXXX' yazan bir kod gördüğümde, bir şeyin değerini belirlediğini söylemek için okudum, bu şeyin o değeri ayarlamaktan başka yan etkileri olmasını beklemiyorum ve bunun doğru olmadığını düşünüyorum. (yani aynı değerde ayarlamaya devam edebilirim ve sorun yok). Bir alana erişmek gibi bir şey. Genel olarak bir 'setXXX' ile birlikte bir 'getXXX' yöntemi görmeyi de beklerdim.

Java ve C ++ 'da beklediğinizin bu olup olmadığını bilmiyorum, ama C #' da beklediğim şey bu, C # 'da olsa Özellikler diye kısa bir el var. Ve burada Özellikler'in nasıl kullanılacağına ilişkin bazı güzel rehberler ( http://msdn.microsoft.com/en-us/library/ms182181.aspx ).

Bu görünüm göz önüne alındığında, seçeceğim arayüz, herhangi bir yan etki olup olmadığına bağlıdır (bu alan değerini değiştirmek dışında):

Eylemin yan etkileri varsa, örneğin bir iletişim kutusu gösteriyorsa "Show ()" ve "Hide ()" ile giderim.

Yan etkileri yoksa, "pencere öğesinin" görünürlüğünü belirlediğimi ve başka bir şeyin bu duruma göre ayarlanacağını ve ardından setVisibility veya setIsVisible kullanacağımı söyleyin. (Ben buna SetVisible demiyorum).

C # 'da (Java hakkında emin değilim), bir UI çerçevesinin nesnelerdeki değişiklikleri dinleyeceği ve Görünürlük gibi bir özellik değiştiğinde UI'yi otomatik olarak yeniden oluşturacağı bir gözlemci modeli kabul etmek oldukça yaygındır. Bu, setIsVisible işlevini çağırarak değeri ayarlamanın yan etkileri var gibi göründüğü, ancak tanımımda görünmediği anlamına gelir. Widget'ın sözleşmesi, "IsVisible" ı temsil eden alan değerini ayarlayarak yerine getirilir.

Başka bir deyişle, form gösterilmeden önce bir etiketin formdaki görünürlüğünü değiştirmem benim için sorun değil. Yani label.getIsVisible == true, ancak form gösterilmemiştir.

Form gösterilmezken Hide () 'u aramam uygun değil.

Biraz değiştirilmiş bir arayüz öneririm:

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

Daha iyi isimler

Bu yöntem adları, geliştiricinin yapılması gerekenlere dayanarak hangi yöntemi kullanacağına karar vermesine yardımcı olur. Oysa SetVisible(bool visible)bu aynı semantik anlam taşır, çünkü bir geliştirici karıştırmayın olabilir Show()ve Hide(), Toggle()harekete belirleyen durumun varlığını ima eder. Böylece, her bir yöntemin ne zaman kullanılacağı geliştirici için sezgisel hale gelir.

Azaltılmış kod yedekleme

Arayüzünüzde çoklu yöntemlere sahip olmanın yararı, arama kodunu basitleştirmesidir. Sadece ortaya çıkarabilir Show()ve Hide(), ama:

• SetVisible()Sahnelerin arkasındaki asıl işi yapmak için muhtemelen bir tür özel yöntem gerekir (ya da Show()ve için gereksiz kodlar yazarsınız Hide()).
• Hangi kodun kullanılacağını seçmek için / else engellerse, çağıran kodun fazladan desteği olabilir. Bu benim görüşüme göre kodu şişiriyor.
• Tüketici olsaydım, kod kısıtlamasını önlemek için SetVisible()(ya da Toggle()gereksiz koddan nefret ederim) zaten ne yaptığını yapan kendi sarmalayıcı fonksiyonumu yazabilirim . Bu nedenle , uygulamada muhtemelen özel bir yöntem olarak var olan bir yöntemi çoğaltmak .

Ben SetVisible(bool)sadece görünürlüğü iki kez değiştirmek (göstermek ve yeniden gizlemek veya gizlemek ve yeniden göstermek) herhangi bir şeyi işlem yapılmadan önceki gibi aynı durumda bırakacak olsaydı kullanmanızı öneririm ( eğer göstermek ve yeniden gizlemek iyidir. bir şey veya bunun tersi, "otomatik olarak" olması beklendiği takdirde yeniden çizim ihtiyacı olan nesneleri bırakır). Bir nesneyi gizlemek ve göstermek, bir bitlik durumun değiştirilmesinden başka bir etkiye sahip olmazsa, görünürlük parametresini kabul eden bazı yöntemlere sahip olmak dış kod için mantıklı olur ve bu kodun yazılması kolaylaşır SetVisible.

Bir nesneyi gizleme ve yeniden gösterme, Z sırasını değiştirme gibi yan etkilere sahipse, bu tür eylemlerin büyük olasılıkla ayrı yöntemlerle gerçekleştirilmesi gerekir. Bu gibi durumlarda, "görünürlük" parametresi kabul eden dış yöntemlerin faydası sınırlı olacak ve bu yüzden bunları kolaylaştırmanın çok az avantajı olacaktır. Ayrıca, bir SetVisibleyöntem (yanlış) nesnelerin görünürlüğündeki değişikliklerin yan etkiler olmadan yapılabileceğini önerecektir.