o switch se diferencia do if pois só é capaz de testar igualdades.?
a função switch possui algumas diferenças em relação à função if, mas ambas são funções de comparação. e é correto afirmar que a diferença entre elas é a capacidade de apenas testar igualdades. a estrutura do switch pode ser melhor analisada a seguir:\switchem cada um dos cases, só é aceito um valor ou, até mesmo, uma string. a comparação sempre será uma comparação de igualdade entre o valor de referência e o valor de cada case. já a função if permite fazer comparações lógicas com uma lógica booleana. a estrutura do if pode ser melhor analisada a seguir:\if
Só testando. <p>não tem muita diferença nao. o que muda é o retorno ser int ou integer. 
agora é uma questão pessoal.. eu não uso apenas objetos. em muitos casos eu uso primitivos.</p> Você pode usar [`RuntimeHelpers.GetHashCode(object)`](http://msdn.microsoft.com/en-us/library/11tbk3h9.aspx)o que exige `object.GetHashCode()`não virtualmente - este é o equivalente a `System.identityHashcode`em Java. Eu acho que é isso que você está depois. Portanto, o seu `IEqualityComparer`iria usar apenas que para hash e`object.ReferenceEquals` de igualdade. não sei, apenas você sabe se é gay ou não. você fala da pontuação do tripadvisor? se for é uma pontuação simbólica o determinar seu nível no tripadivisor e não para trocar no múltiplos. abs douglas não, configura o switch assim:

switch:

- platform: mqtt

name: "sonoff power"

state\_topic: "stat/sonoff/power"

command\_topic: "cmnd/sonoff/power"

availability\_topic: "tele/sonoff/lwt"

qos: 1

payload\_on: "on"

payload\_off: "off"

payload\_available: "online"

payload… <p><strong>principais diferenças:</strong></p><ul> <li> <p>ambos scala e f # combinam programação imperativa de oo e programação funcional em uma linguagem. porém, sua abordagem para a unificação de paradigmas é muito diferente. scala tenta <em> funde </em> os dois paradigmas em um (chamamos de paradigma funcional do objeto), enquanto f # fornece os dois paradigmas lado a lado.por exemplo, tipos de dados algébricos em f # são construções puramente funcionais sem oo'ness nelas, enquanto os adts em scala ainda são classes e objetos regulares. (observação: no processo de compilação para o bytecode do clr, até mesmo os ft adts se tornam classes e objetos)). mas eles não são visíveis para o programador f # no nível da fonte.)</p> </li> <li> <p>o f # possui inferência completa do tipo hindley-milner. scala possui inferência parcial de tipo. o suporte para subtipagem e oo-pura) torna impossível a inferência de tipo de estilo hindley-milner para o scala.</p> </li> <li> <p>scala é uma linguagem muito mais minimalista que o f #. scala possui um conjunto ortogonal muito pequeno de construções que são reutilizadas em todo o idioma. o f # parece introduzir uma nova sintaxe para cada pequena coisa, tornando-se muito pesado quanto à sintaxe em comparação com o scala. (scala tem 40 palavras-chave, enquanto f # tem 97. isso deve lhe dizer uma coisa. :-)</p> </li> <li> <p>f # sendo uma linguagem da microsoft tem um excelente suporte ide na forma do visual studio. as coisas não são tão boas no lado scala. o lado do scala $ . o plugin eclipse ainda não é o mesmo vale para o plug-in netbeans. idea parece ser a sua melhor aposta no momento, apesar de nem sequer chegar perto do que você recebe java ides. (para os fãs do emacs, existe o ensime. ouvi muitas coisas boas sobre este pacote, mas ainda não o testei.)</p> </li> <li> <p>o scala possui um sistema do tipo muito mais poderoso (e complexo) que o f #.</p> </li> </ul><hr><p><strong>outras diferenças:</strong></p><ul> <li> <p>as funções f # são exibidas por padrão. em scala, o curry está disponível, mas não é usado com muita frequência.</p> </li> <li> <p>a sintaxe do scala é uma mistura da java, standard ml, haskell, erlang e muitas outras linguagens. a sintaxe do f # é inspirada nos de ocaml, c # e haskell.</p> </li> <li> <p>o scala suporta tipos e classes superiores. f # não.</p> </li> <li> <p>scala é muito mais acessível a dsls que f #.</p> </li> </ul><hr><p>ps: eu amo ambos scala e f #, e espero que eles se tornem idiomas predominantes de suas respectivas plataformas no futuro. :-)</p> <p>aqui está uma versão que funciona em c/c++ que não depende de tamanhos inteiros ou tem o problema de estouro (ou seja, x * y&gt; = 0 não funciona)</p><pre><code>bool samesign(int x, int y) { return (x &gt;= 0) ^ (y &lt; 0); } </code></pre><p>claro, você pode dar uma olhada e criar um modelo:</p><pre><code>template &lt;typename valuetype&gt; bool samesign(typename valuetype x, typename valuetype y) { return (x &gt;= 0) ^ (y &lt; 0); } </code></pre><p>nota: como estamos usando exclusive ou, queremos que o lhs e o rhs sejam diferentes quando os sinais forem os mesmos, portanto, a verificação diferente será zero.</p> <p>na verdade a incrementação da variável ocorre somente ao final do bloco, então seria mais ou menos o que você disse. no primeiro caso seria</p>
<p><em>não soma pois quebra antes</em> </p>
<p>e no último seria</p>
<p><em>logo o i nao incrementa para 1</em></p>
<p>pode ser uma analogia sim, mas é um pouco inadequada e pode levar a equívocos no futuro. é mais parecido com uma interrupção forçada, como uma função sem tipo de retorno que é interrompida dada uma condição:</p>
<pre class="prettyprint"><code>public void funcao() {
 // faz algumas coisas
 if (condicao) {
 return;
 }
 // faz outras coisas
}</code></pre> <p>olá marcos! veja bem, pode-se fazer uma analogia, em certo ponto, com um while, mas isso não é um while. em um while você faz a repetição de determinada regra de negócio de acordo com a condição por você indicada. no chain of responsibility, necessáriamente não será repetida a mesma regra de negócio, veja que cada classe tem sua própria verificação, ou seja regras de negócios diferentes.</p>
<p>mas eu entendi o que você quis dizer, você está se referindo ao fato de ficar repetindo a verificação enquanto uma não for atendida. por isso eu disse que dá para fazer uma analogia em certo ponto. mas repare que isso foi apenas uma coincidência, pois com o chain of responsibility eu não precisaria parar a verificação ao achar uma que atendesse a condição, poderia continuar com todas, ja com o while não.</p>
<p>enfim, para o caso do exercício e da aula é possível sim fazer essa analogia, mas tenha em mente que o chain of responsibility não é uma espécie de while.</p>
<p>espero ter ajudado! bons estudos!</p>