O que é melhor e por quê? (Do ponto de vista do design da interface):
a) Ter dois Show()
e Hide()
funções
b) Ter uma SetVisible(bool visible)
função
EDIT: Por exemplo, algum objeto tem estado de visibilidade e esta função é usada para alterá-lo.
c) ter todos os três Show()
, Hide()
, SetVisible(bool visible)
funções
java
c++
interfaces
user3123061
fonte
fonte
Respostas:
Eu prefiro
SetVisible(bool visible)
, porque me permite escrever o código do cliente assim:em vez de ter que escrever
A
SetVisible
abordagem também pode permitir uma implementação mais fácil. Por exemplo, se uma classe concreta específica simplesmente delega o método para suas classes compostas,SetVisible
significa menos um método para implementar.fonte
MyObject.Visible = false;
parece-me ainda mais intuitivo do queMyObject.SetVisible(false);
SetVisible()
não sugere (para mim) que você está realmente exibindo alguma coisa. Parece mais que você está configurando a propriedade de visibilidade de um objeto, possivelmente deixando para um métodoRefresh()
ou correspondenteRedisplay()
para verificar o valor dessa propriedade para determinar se o objeto deve ser exibido ou oculto.setVisible(true)
desencadeasse um processo em que o objeto seria desenhado quando o sistema estivesse ocioso, se não antes. Eu esperaria querefresh
isso fosse útil para acelerar a exibição do objeto, mas que o objeto acabasse sendo desenhado independentemente (a menos que, por exemplo, sua visibilidade estivesse definidafalse
antes que isso ocorresse).Não concordo com todos os pôsteres que sugerem várias funções para fazer a mesma coisa. Enquanto três funções em vez de um pode não parecer muito inchaço, lembre-se que sua classe é provável que acabe com muitas dessas funções (por exemplo
setEnabled
,enable
,disable
) e, portanto, esta abordagem irá acabar com um muito interface da classe maior. Além disso, é provável que você acabe com várias funções / propriedades de som semelhantes / o que quer que seja da sua classe e a multiplicação de funções obscurecerá ainda mais qual delas combina com o quê.Nas linguagens que suportam propriedades, essas devem ser preferidas, mas, como nem Java nem C ++, acho que esse é um ponto discutível.
Eu acho que
setVisible()
deveria ser preferido por estas razões:setVisible(false)
você chama,setVisible(true)
enquanto o oposto dehide()
poderia ser facilmentereveal()
.setVisible(wantToSee)
vez de usar umaif
instrução.setX()
formato é generalizado, para que você possa ter um conjunto de funções consistentes, enquanto a abordagem com verbetes gera uma série de funções que podem ser difíceis de localizar se você não sabe o que está procurando. A consistência nas APIs as torna consideravelmente mais fáceis de aprender e lembrar.fonte
Depende do que mostrar e ocultar significa no contexto. Primeiro, você deseja descobrir qual é o seu "caminho principal" e se concentrar em desenvolver isso:
setVisible(bool)
show()
ehide()
OK, agora que você codificou o núcleo "padrão ouro" dele, precisa descobrir se vale a pena adicionar métodos de conveniência finos no outro estilo, para facilitar a vida de quem vai usar seu objeto.
setVisible(bool)
setVisible(a==b)
)show()
ehide()
onSuccess(widget.show)
)TLDR: Descubra qual é o mais importante, implemente-o e, em seguida, pergunte-se se vale a pena adicionar o outro estilo como métodos de conveniência simples.
fonte
Eu diria "todos os três".
Show()
eHide()
tendem a ser mais fáceis de grok do queSetVisible(true)
eSetVisible(false)
. No entanto, quando você deseja definir visibilidade logicamente, é melhor ter um método usando umbool
ao invés de construir um emif
torno dissobool
.Você pode oferecer suporte aos três sem duplicar a lógica e o mínimo padrão:
Como alternativa, se as coisas que você está quebrando tiverem uma
SetVisible
API mais -ish:fonte
System.Windows.Forms.Timer
. Pessoalmente, acho isso confuso. Quando vejo ambosShow
eSetVisible
, minha primeira inclinação é pensar se há alguma diferença importante entre as duas funções.Prefiro show () e hide (); de fato, todo método que recebe um booleano pode ser alterado por dois métodos, para expressar melhor a intenção da API. Por exemplo, Robert Martin em código limpo recomenda preferir métodos com zero argumentos sobre métodos com um argumento.
Outro argumento importante para mim é a legibilidade, na minha opinião, um bom código pode ser lido como prosa, é uma prosa realmente estranha algo como "main_window setVisible false" em vez de "main_window hide", você escreve ou fala assim normalmente ?, por que usar esse estranho construção de linguagem em programas de software quando é perfeitamente possível usar uma linguagem mais natural ?.
fonte
it.setVisible(false); it.setVisible(true);
não afetasse a visibilidade dos pais de um controle, nem a ordem Z ou o local do controle. Por outro ladohide(); show()
,; plausivelmente, poderia forçar o pai de um controle a ficar visível, movê-lo acima de outros controles e limitar sua posição a um lugar que possa ser visto. Em alguns casos, é útil ter um meio de ter certeza que algo é realmente visível (como o já mencionadoshow()
, mas em outros casos é útil para mudar a bandeira visibilidade sem alterar qualquer outra coisa.Acredito que, quanto mais o método for expressivo, mais legível e, consequentemente, sustentável o código será. Considere os dois casos a seguir:
Caso 1:
Caso 2:
No primeiro caso, fica claro o que a função "setVisible" está fazendo, mas se você quiser lê-la, diria:
Embora seja mais descritivo dizer:
que alterará a função "Caso 1" para o seguinte:
produz mais código, mas é mais legível.
O segundo caso tem uma falha óbvia, ou seja, você já sabe que deseja mostrar o painel; então, por que não usar a função "Mostrar"?
Não estou dizendo que o uso de "setVisible" esteja absolutamente errado, mas fica confuso quando você tenta ler o código não escrito por você com o tempo e não está de acordo com a regra "A função deve executar apenas uma operação".
fonte
show customer panel iff the user/customer is enabled
. Concordo que pode haver muitas condições mais complexas que não são tão fáceis de ler quanto o seu exemplo; no entanto, nesses casos, eu as dividiria em linhas diferentes.Acredito que a alternativa
Hide()
/Show()
seja atraente porque é mais fácil entender o que está acontecendo do que comSetVisible(true)
, embora seja preferível ter uma única função, pois evita muitos condicionais.Se for esse o caso, sugiro usar uma enumeração como entrada para
SetVisible
, para que você obtenha umSetVisible(Visibility.Visible)
ou outroSetVisible(Visibility.Hidden)
. Você tem uma única função e pode ler instantaneamente que ação está sendo executada.Usando as convenções de nomenclatura de Java, você teria talvez
setVisible(Visibility.VISIBLE)
ousetVisible(Visibility.HIDDEN)
.fonte
Concordo com a resposta de Darien, mas queria acrescentar um ponto de vista da perspectiva de programadores em C #.
Quando vejo o código que diz 'setXXX', li que para dizer que está definindo um valor em uma coisa, não espero que isso tenha efeitos colaterais além de definir esse valor, e espero que seja idempotente (ou seja, posso continuar definindo-o com o mesmo valor e tudo bem). É como acessar um campo. Geralmente, eu também esperaria ver um método 'getXXX' junto com um 'setXXX'.
Não sei se é isso que você espera em Java e C ++, mas é o que eu esperaria em C #, embora em C # exista uma pequena mão para isso chamado Propriedades. E aqui estão algumas orientações interessantes sobre como usar as Propriedades ( http://msdn.microsoft.com/en-us/library/ms182181.aspx ).
Dada essa visão, a interface que eu escolheria depende apenas se houver algum efeito colateral (além de alterar esse valor do campo):
Se a execução da ação tiver efeitos colaterais, por exemplo, está mostrando uma caixa de diálogo, então eu usaria "Show ()" e "Hide ()".
Se não tiver efeitos colaterais, digamos que estou definindo a visibilidade de um "widget" e outra coisa renderize esse widget dependendo do estado, então eu usaria setVisibility ou setIsVisible. (Eu não chamaria SetVisible).
Em C # (não tenho certeza sobre Java), é bastante comum adotar um padrão de observador, em que uma estrutura de interface do usuário escuta alterações nos objetos e renderiza automaticamente a interface do usuário quando uma propriedade como Visibility é alterada. Isso significa que definir o valor chamando setIsVisible parece ter efeitos colaterais, mas, na minha definição, não. O contrato do widget é cumprido definindo seu valor de campo representando "IsVisible".
Em outras palavras, não há problema em alternar a visibilidade de um rótulo em um formulário antes que o formulário seja mostrado. Ou seja, label.getIsVisible == true, mas o formulário não é mostrado.
Não é legal chamar Hide () quando o formulário não está sendo mostrado.
fonte
getXXX()
esetXXX()
métodos como uma maneira de acessar um campo sem efeitos colaterais parecem Java e não C #. É assim que você deve fazê-lo em Java, porque ele não possui propriedades. Se eu vi um código como esse em C #, acho que foi escrito por um desenvolvedor Java que ainda não havia aprendido sobre propriedades em C #.SetVisibility
.getXX
chamada tiver umsetXX
método correspondente ,setYY
não deverá afetá-la, mas poderá afetar umagetZZ
chamada que não possui umsetZZ
método.Eu sugeriria uma interface ligeiramente modificada:
Melhores nomes
Esses nomes de métodos ajudam o desenvolvedor a decidir qual método usar, com base no que precisa ser feito. Considerando que
SetVisible(bool visible)
pode confundir um desenvolvedor porque ele transmite o mesmo significado semântico queShow()
eHide()
,Toggle()
implica a existência de uma condição que determina a ação. Assim, torna-se intuitivo para o desenvolvedor quando usar cada método.Redundância de código reduzida
O benefício de ter vários métodos em sua interface é que simplifica o código de chamada. Você pode apenas expor
Show()
eHide()
, mas:SetVisible()
método privado para fazer o trabalho real nos bastidores (ou escrever código redundante paraShow()
eHide()
).SetVisible()
(ouToggle()
) já faz para evitar o inchaço do código (eu odeio código redundante). Assim, duplicar um método que provavelmente já existe como método privado na implementação.fonte
Eu sugeriria que use
SetVisible(bool)
if if only, se alternar a visibilidade duas vezes (mostrar e re-ocultar, ou ocultar e re-mostrar) deixaria as coisas essencialmente no mesmo estado de antes da operação (é bom se mostrar e ocultar algo ou vice-versa deixa os objetos precisando de um redesenho, desde que se possa esperar que ocorra "automaticamente"). Se ocultar e mostrar um objeto não tiver outro efeito além de alterar um bit de estado, faria sentido para o código externo ter alguns métodos que aceitem um parâmetro de visibilidade, e a gravação desse código será facilitadaSetVisible
.Se ocultar e mostrar novamente um objeto pode ter efeitos colaterais, como alterar a ordem Z, é mais provável que essas ações sejam executadas por métodos separados. Nesses casos, a utilidade de métodos externos que aceitam um parâmetro de "visibilidade" será limitada e, portanto, haverá pouca vantagem em facilitá-los. Além disso, um
SetVisible
método (erroneamente) sugere que alterações na visibilidade dos objetos podem ser realizadas sem efeitos colaterais.fonte