C# Quiz

Os dois números são int, então a divisão é inteira: o resultado é 3, e a parte decimal é jogada fora (não arredonda para 4).

Com um double na conta (2.0), a divisão tem casas decimais. No código, o separador é sempre o ponto; na saída, o C# usa o formato da cultura da máquina, e em pt-BR a casa decimal é a vírgula.

O double guarda os números em base 2, e 0,1 e 0,2 não têm representação exata: a soma dá 0,30000000000000004, que não é igual a 0,3. Com decimal (0.1m + 0.2m == 0.3m), dá True. Por isso, dinheiro em decimal.

O + é resolvido da esquerda para a direita. "Total: " + 2 junta texto e número e dá o texto "Total: 2"; depois, "Total: 2" + 3 dá "Total: 23". Para somar antes, use parênteses: "Total: " + (2 + 3), ou a interpolação $"Total: {2 + 3}".

O x++ (pós-fixado) usa o valor atual (5) e só depois soma 1. Quando o segundo x é lido, ele já vale 6. Com ++x, a saída seria 6 6.

O var não é um tipo: o compilador olha o valor e escolhe. Um número com ponto e sem sufixo é double (preco.GetType() mostra System.Double). Para dinheiro, escreva 19.90m ou decimal preco = 19.90m;.

O formato C (currency, moeda) usa a moeda e os separadores da cultura da máquina: em pt-BR, R$, ponto nos milhares, vírgula nos centavos e sempre duas casas.

Strings são imutáveis: ToUpper() não muda o texto, ele devolve um texto novo, que aqui foi jogado fora. Para guardar, escreva texto = texto.ToUpper();.

As posições começam em 0: b é 0, a é 1, o primeiro n é 2. Quando a letra não existe, IndexOf não lança exceção: devolve -1.

^1 quer dizer "o primeiro a partir do fim", ou seja, o último elemento. É o mesmo que v[v.Length - 1]. (^0 seria uma posição depois do fim e lançaria exceção.)

Um array é um tipo de referência: copia = v não copia os números, copia o endereço. As duas variáveis apontam para o mesmo array, então mudar por uma aparece na outra. Para uma cópia de verdade, use v.Clone(), [.. v] ou v.ToArray().

O i começa em 0 e o laço roda enquanto i < 3: com 0, 1 e 2. Quando i vira 3, a condição é falsa e o laço para antes de mostrar. Write não pula linha, por isso sai tudo junto.

O primeiro número entra no sorteio; o segundo é o limite de fora. Next(1, 7) é um dado: 1, 2, 3, 4, 5 ou 6. Para 1 a 100, Next(1, 101).

Em C e Java, sem break o programa continuaria no case de baixo. O C# proíbe isso, porque quase sempre é um esquecimento: todo case com código tem de terminar com break, return ou throw.

O do while roda o corpo antes de testar a condição: mesmo com false, roda uma vez. Um while (false) { … } não rodaria nenhuma.

Parse confia que o texto é um número. Para o que o usuário digita, use int.TryParse(texto, out int numero), que devolve false em vez de lançar exceção.

Por padrão, Math.Round usa o arredondamento bancário: no meio exato (,5), vai para o número par mais próximo. 2,5 vira 2 e 3,5 vira 4. Para o arredondamento da escola, use Math.Round(2.5, MidpointRounding.AwayFromZero), que dá 3.

O cast (int) corta a parte decimal (não arredonda): 7,9 vira 7. Um byte vai de 0 a 255; o cast fica só com os 8 bits de baixo de 300, que dão 300 − 256 = 44. Sem checked, ninguém avisa. Com checked((byte)trezentos), viria uma OverflowException.

O C# não deixa ler uma variável local sem valor, para você nunca usar um "lixo" da memória. Dê um valor inicial (int total = 0;) ou garanta que todo caminho do código atribua antes de ler. (Uma variável que não existe é o CS0103; declarada duas vezes, o CS0128.)

O intervalo ..2 vai do começo até a posição 2, sem incluir a 2: as posições 0 e 1. O fim de um intervalo nunca entra.

int? é um inteiro que aceita null. O ?? é o "valor reserva": se o da esquerda for null, usa o da direita.

O ?. só lê Length se apelido não for null; se for, o resultado inteiro é null, e na interpolação um null vira texto vazio. Sem o ?, apelido.Length lançaria NullReferenceException (e o compilador avisaria com CS8602).

Um record compara pelo conteúdo: dois pontos com os mesmos valores são iguais. Uma classe comum compara pela referência: dois new são dois objetos diferentes, mesmo com os mesmos valores.

Ponto é um struct, um tipo de valor: b = a faz uma cópia inteira. Mudar b não mexe em a. Se Ponto fosse uma class, a resposta seria 5.

List é uma classe: as duas variáveis guardam o endereço da mesma lista no heap. O Add por uma aparece na outra.

É o encapsulamento: o saldo só muda pelos métodos da classe (Depositar, Sacar), que conferem as regras.

Falar é virtual e o cachorro faz override: vale a versão do objeto de verdade, um Cachorro (polimorfismo). Mover não é virtual; o new só esconde o da mãe, e, por uma variável do tipo Animal, quem roda é o Mover do Animal.

Todo construtor da filha chama um construtor da mãe. Sem : base(titular), o C# tenta o construtor sem parâmetros. Como a Conta só tem o que pede o titular, a compilação falha.

A divisão inteira por zero lança DivideByZeroException: o resto do try (o B) é pulado, o catch roda (C) e o finally roda sempre, com ou sem exceção (F).

throw; sozinho relança a mesma exceção com o rastro original (o stack trace). throw ex; recomeça o rastro na linha do catch, e você perde a linha em que o erro nasceu (o analisador avisa com CA2200).

Um campo static é da classe, não de cada objeto: existe um Total só, que começa em 0 (o valor padrão de int), e cada construtor soma 1 nele.

As propriedades de um record posicional só recebem valor na criação. A expressão with cria um record novo, igual ao antigo, com as propriedades indicadas trocadas.

Ler uma chave que não existe com [ ] lança exceção. Para perguntar com segurança, use TryGetValue("caneta", out int qtd) ou GetValueOrDefault("caneta").

A consulta LINQ tem execução adiada: o Where não filtra na hora, só guarda a receita. Ela roda no Count(), quando a lista já tem o 10: os maiores que 1 são 2, 3 e 10. Para "fotografar" o resultado na hora, use .ToList().

A soma de nada é zero, sem problema. Mas a média de nada não existe (seria 0 dividido por 0), e o LINQ avisa com a exceção. Confira com Any() antes, ou use DefaultIfEmpty().

Um HashSet não guarda repetidos. O Add de um item que já está lá não lança exceção: devolve false e não muda nada.

A fila é "primeiro a entrar, primeiro a sair", como a fila do banco: sai o 1. A pilha é "último a entrar, primeiro a sair", como uma pilha de pratos: sai o 3, que está no topo.

O foreach confere se a lista mudou debaixo dele e, se mudou, lança a exceção na próxima volta. Ache primeiro e remova depois, ou use RemoveAll(condição).

O await "desembrulha" a Task<string>: enquanto a leitura não termina, o método fica pausado e a thread fica livre para outras coisas; quando termina, o método continua com o texto. Esquecer o await ao chamar um método async dá o aviso CS4014.

O coletor libera o que não é mais alcançável, e não tem hora marcada. Por isso, arquivos e conexões se fecham com using (que chama o Dispose na hora), e não esperando o coletor. E uma lista static que só cresce mantém tudo alcançável: é o "vazamento" de memória do C#.