Introdução ao Tratamento de Exceções

Nesse post iremos aprender como manipular exceções em Delphi.

No desenvolvimento de software, as exceções são eventos que ocorrem durante a execução de um programa e interrompem o fluxo normal de instruções. Esses eventos podem ser causados por uma variedade de razões, como erros de programação, falta de recursos do sistema, ou problemas externos como falhas de hardware. Em Delphi, o manejo de exceções é uma prática essencial para criar aplicativos robustos e confiáveis.

Delphi fornece um sistema poderoso para captura e tratamento de exceções, permitindo que os desenvolvedores antecipem problemas e implementem soluções para evitar que o programa falhe inesperadamente. Neste artigo, vamos explorar como utilizar try...except e try...finally para manejar exceções, além de aprender a criar e lançar exceções personalizadas.

Uso de try...except e try...finally

Bloco try...except

O bloco try...except é usado para capturar e tratar exceções que ocorrem em uma determinada seção do código. Ele permite que você especifique uma resposta a exceções e continue a execução do programa de forma controlada.

try
  // Código que pode gerar uma exceção
except
  on E: Exception do
    // Tratamento da exceção
    ShowMessage('Ocorreu um erro: ' + E.Message);
end;

No exemplo acima, o bloco try contém o código que pode gerar uma exceção. Se uma exceção ocorrer, o controle é passado para o bloco except, onde a exceção é tratada. A variável E representa a exceção capturada e E.Message contém a mensagem de erro associada.

Bloco try...finally

O bloco try...finally é usado quando você precisa garantir que uma certa seção do código seja executada, independentemente de uma exceção ter sido lançada ou não. Isso é particularmente útil para liberar recursos ou realizar tarefas de limpeza.

var
  FileStream: TFileStream;
begin
  FileStream := TFileStream.Create('example.txt', fmOpenRead);
  try
    // Código que pode gerar uma exceção
  finally
    // Código que será sempre executado
    FileStream.Free;
  end;
end;

No exemplo acima, o objeto FileStream é criado no bloco try e liberado no bloco finally, garantindo que FileStream.Free será chamado, mesmo que ocorra uma exceção durante a leitura do arquivo.

Criando e Lançando Exceções Personalizadas

Além de capturar e tratar exceções, Delphi permite que você crie suas próprias exceções personalizadas. Isso é útil para sinalizar condições de erro específicas que não são cobertas pelas exceções padrão da linguagem.

Criando Exceções Personalizadas

Para criar uma exceção personalizada, você deve definir uma nova classe que derive de Exception.

type
  EMyCustomException = class(Exception)
  end;

Lançando Exceções Personalizadas

Uma vez que você tenha definido sua exceção personalizada, você pode lançá-la usando a palavra-chave raise.

procedure DoSomething;
begin
  if SomeCondition then
    raise EMyCustomException.Create('Ocorreu um erro específico');
end;

Tratando Exceções Personalizadas

Você pode tratar suas exceções personalizadas da mesma forma que trata as exceções padrão.

try
  DoSomething;
except
  on E: EMyCustomException do
    ShowMessage('Tratando uma exceção personalizada: ' + E.Message);
end;

Exemplo Prático

Vamos criar um exemplo prático que demonstra o uso de try...except, try...finally, e exceções personalizadas. O exemplo envolve uma função que lê um arquivo de texto e lança uma exceção personalizada se o arquivo não for encontrado.

Configurando o Ambiente

1. Abrindo o Delphi: Abra o Delphi e crie um novo projeto VCL Forms Application
2. Configurando o Formulário Principal: Adicione o seguinte componente ao formulário:
   • TButton(Button1) – Caption – Ler Arquivo

Código Fonte

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type

  EFileNotFoundException = class(Exception)
  end;


  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    procedure ReadFile(const FileName: string);
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  try
    ReadFile('nonexistent.txt');
  except
    on E: EFileNotFoundException do
      ShowMessage('Exceção capturada no nível principal: ' + E.Message);
    on E: Exception do
      ShowMessage('Erro não esperado: ' + E.Message);
  end;
end;

procedure TForm1.ReadFile(const FileName: string);
var
  FileStream: TFileStream;
  Buffer: TBytes;
begin
  if not FileExists(FileName) then
    raise EFileNotFoundException.Create('Arquivo não encontrado: ' + FileName);

  FileStream := TFileStream.Create(FileName, fmOpenRead);
  try
    try
      SetLength(Buffer, FileStream.Size);
      FileStream.ReadBuffer(Buffer, FileStream.Size);
      ShowMessage('Arquivo lido com sucesso');
    except
      on E: EFileNotFoundException do //Trata a exceção personalizada
        ShowMessage('Erro de arquivo: ' + E.Message);
      on E: Exception do //Trata exceções em geral
        ShowMessage('Erro geral: ' + E.Message);
    end;
  finally
    FileStream.Free;
  end;
end;

end.

Explicação do Código

1. Definição da Exceção Personalizada: A classe EFileNotFoundException é definida para representar erros específicos de arquivo não encontrado.
2. Função ReadFile:
   • Verifica se o arquivo existe usando FileExists. Se não existir, lança EFileNotFoundException.
   • Tenta abrir e ler o arquivo usando um TFileStream.
   • Usa try...except para capturar e tratar tanto a exceção personalizada quanto exceções gerais.
   • Usa try...finally para garantir que o FileStream seja sempre liberado.
3. Bloco Principal (Button1Click):
   • Tenta chamar ReadFile e captura exceções, exibindo mensagens apropriadas para EFileNotFoundException e exceções gerais.

Código fonte do exemplo

Você pode fazer o download do exemplo do projeto através do repositório do github:

https://github.com/Gisele-de-Melo/Exception

Conclusão

O manejo de exceções em Delphi é uma habilidade essencial para desenvolver aplicações robustas e confiáveis. Com os blocos try...except e try...finally, você pode capturar e tratar erros de forma eficaz, garantindo que seus programas continuem a funcionar mesmo diante de problemas inesperados. Além disso, a criação de exceções personalizadas permite que você sinalize condições de erro específicas, facilitando o diagnóstico e a correção de problemas. Com o conhecimento adquirido, você está preparado para lidar com exceções em suas aplicações Delphi de maneira eficiente e profissional.

Posts Relacionados

Arquivo Texto com TStringList em Delphi

Livros + e-books

Delphi para Android e iOS

Delphi Start

Programando em Delphi XE

Aprenda programar Delphi

Banco de Dados RAD Delphi

Delphi Programming Projects