Carregando...

try and catch

Envolva a leitura má de slots[5] em try e catch para o programa não terminar em IndexOutOfRangeException. Imprima blocked dentro do catch e depois after fora dos dois blocos. Compile Pine e execute dotnet run. O ecrã deve mostrar blocked e depois after. Um segundo ficheiro mantém slots[0] dentro de try para o catch ser saltado e o ecrã mostrar 2 e depois after. Deixe throw para a página seguinte.

Apanhar o índice mau

A página de exceções mostrou que imprimir slots[5] em {2, 4} lança IndexOutOfRangeException e para a execução. Esta página mantém a mesma história do array e acrescenta o tratamento. Abra um novo ficheiro de ensino chamado Pine. Mantenha o nome da classe pública Pine para coincidir com o nome do ficheiro. Apague mains restantes de bare exceptions que param sem catch, listas de e qualquer ou ReadLine. O programa não deve esperar escrita.
Dentro de main, mantenha o mesmo array pequeno:
int[] slots = {2, 4};
Coloque a impressão má dentro de try:
Console.WriteLine(slots[5]);
Depois escreva um catch que nomeie IndexOutOfRangeException e imprima blocked. Depois de todo o try e catch, imprima after. O nome do parâmetro do catch pode ser uma letra curta como e; não precisa de imprimir o objeto da exceção nesta página.

Pine catch bad index

csharp
using System;

public class Pine
{
    public static void Main()
    {
        int[] slots = {2, 4};
        try
        {
            Console.WriteLine(slots[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("blocked");
        }
        Console.WriteLine("after");
    }
}

Da pasta que guarda Pine, execute dotnet run. Quando parênteses, chavetas e ponto e vírgula coincidem, o javac não escreve uma linha própria. Depois execute dotnet run — não dotnet run.java. Tire o final .java do comando de execução.
O ecrã mostra blocked e depois after. O índice mau continua a lançar dentro de try. O catch trata essa exceção nomeada e imprime blocked. A linha Console.WriteLine("after"); está fora, por isso também corre. O programa não termina nessa paragem como o ficheiro mau nu de bare exceptions.
Imagine uma segunda impressão ainda dentro do mesmo try depois de slots[5], por exemplo uma linha que imprimiria rice. Essa linha não corre. Apanhar a exceção não volta a terminar o resto do try. Só o corpo do catch corre para essa paragem; depois o controlo continua após o catch. Mantenha a ideia clara: o tratamento salta as linhas restantes dentro de try depois do ponto de lançamento.
Se o terminal esperar entrada de teclado, ainda há uma chamada ReadLine de um exercício antigo num ficheiro. Apague-a. Se só vir um relatório de pilha sem a linha blocked, falta o catch ou o nome da exceção não coincide. Se vir só 2 sem after, talvez ainda esteja a executar um bare exceptions seguro antigo — passe a dotnet run com o ficheiro de ensino do catch.

Quando o try termina, o catch fica quieto

Um segundo programa usa a mesma forma de try e catch, mas a impressão dentro de try pede um lugar escrito: slots[0]. Todas as linhas dentro de try terminam. O corpo do catch não corre.

Pine safe index skips catch

csharp
using System;

public class Pine
{
    public static void Main()
    {
        int[] slots = {2, 4};
        try
        {
            Console.WriteLine(slots[0]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("blocked");
        }
        Console.WriteLine("after");
    }
}

Compile com dotnet run e depois execute dotnet run. O ecrã mostra 2 e depois after. A palavra blocked não é impressa, porque não houve IndexOutOfRangeException. O catch ficou quieto. A linha after ainda corre porque está fora de ambos os blocos — o mesmo sítio da demo do catch.
Percorra o contraste uma vez. Primeiro ficheiro: índice mau, catch imprime blocked, depois after. Segundo ficheiro: índice seguro, catch saltado, ecrã 2 depois after. Ambos mantêm Pine e o mesmo nome de tipo do catch. Só o índice dentro de try muda. Essa única mudança basta para ver quando o catch corre e quando não.
Não invente um throw nesta página. Está a apanhar uma exceção que uma leitura má do array já provoca. A página seguinte é sobre lançar de propósito. Também não envolva hoje cada impressão calma do curso dentro de try — esta lição usa try onde um índice mau conhecido precisa de um caminho tratado.

O nome do catch tem de coincidir

A cláusula catch nomeia um tipo de exceção. Nesta página esse tipo é IndexOutOfRangeException, coincidindo com o índice mau. Se escrevesse catch (NullReferenceException e) à volta de slots[5], esse catch não trataria a paragem. O programa ainda terminaria com IndexOutOfRangeException, e nem blocked nem after seriam impressos para esse catch que não coincide. Mantenha o tipo coincidente nos ficheiros de ensino.
Existem outros nomes de exceção em C#. Esta página fica com um par claro: um índice mau de array e IndexOutOfRangeException. Não precisa de um catálogo de cada tipo apanhável antes de praticar esta forma. Faça coincidir o nome que viu na página de exceções.

Comparado com a paragem nua do bare exceptions

Na página de exceções, dotnet run com slots[5] parou e mostrou um relatório de pilha. Nesta página, dotnet run com o mesmo índice mau imprime blocked e continua até after. A história do array não mudou. O tratamento mudou. Mantenha ficheiros bare exceptions só como história se ainda estiverem perto; execute dotnet run para as demos do catch para o ecrã coincidir com esta lição.
A história nullable ainda imprime 9 de uma lista se guardar esse ficheiro antigo. Esse caminho não é a história do catch. Apague ou ignore demos restantes de int? dentro de Pine para o ficheiro de ensino ficar em int[] slots mais try e catch.

O que esta página deixa para throwing

Esta página apanha uma exceção que uma linha já encontra. A página seguinte introduz throw para sinalizar um problema você mesmo. Fique aqui com um catch que coincida e com ver after continuar. Ainda não acrescente um throw manual como requisito nestes ficheiros Pine.

Antes de throwing

Pode apanhar IndexOutOfRangeException de slots[5] e ver blocked, depois after. Pode manter slots[0] dentro de try e ver 2, depois after, com catch saltado. Compile Pine e execute dotnet run para cada demo guardada à vez. O nome do catch coincidiu com a paragem do índice mau. A página seguinte é throwing, onde causa uma paragem de propósito.
Mantenha a demo do catch para um caminho tratado. Mantenha o try seguro para saltar o catch em silêncio. Mantenha o throw manual fora desta página. Esses três hábitos são o ponto de controlo antes de avançar. Quando blocked e depois after aparecerem após a execução do índice mau de dotnet run, try e catch fizeram o trabalho desta lição e está pronto para o tema seguinte sobre throwing.

🧠 Teste Seu Conhecimento

Pronto para Começar

Teste Seu Conhecimento

Desafie-se com este questionário interativo e veja o quão bem você entende o tópico

❓
5
Perguntas
🎯
70%
Para Passar
♾️
∞
Tempo
🔄
∞
Tentativas

📝 Instruções

  • Leia cada pergunta cuidadosamente
  • Selecione a melhor resposta para cada pergunta
  • Você pode refazer o quiz quantas vezes quiser
  • Seu progresso será mostrado no topo