Depois de implementar o comando throw() e introduzir a palavra-chave Try(Expression), estamos animados para revelar a próxima evolução no sistema de tratamento de erros de 4D: a introdução de blocos de código Try-Catch!

A partir de 4D 20 R5, os usuários podem melhorar as suas capacidades de tratamento de erros aproveitando o poder das novas palavras-chave Try, Catch, e End try.
Para ilustrar a aplicação prática destas novas palavras-chave, vamos explorar um exemplo que envolve a criação de faturas com linhas de faturação. Este exemplo destacará os benefícios imediatos destas novas palavras-chave:

Function createInvoice($customer: cs.customerEntity; $items: Collection; $invoiceRef: Text) : cs.invoiceEntity
var $newInvoice : cs.invoiceEntity
var $newInvoiceLine : cs.invoiceLineEntity
var $item : Object

ds .startTransaction()
Try
$newInvoice :=This.new()
$newInvoice .customer:=$customer
$newInvoice .invoiceRef:=$invoiceRef
For each ($item; $items)
$newInvoiceLine :=ds.invoiceLine.new()
$newInvoiceLine .item:=$item.item
$newInvoiceLine .amount:=$item.amount
$newInvoiceLine .invoice invoiceRef $invoiceRef
items:=$newInvoice
$newInvoiceLine .save()
End for each
$newInvoice .save()
ds .validateTransaction()
Catch
ds .cancelTransaction()
$newInvoice :=Null
ds .logErrors({\
message : "Invoice creation failed";\
errors : Last errors;\
customer : $customer.ID;\
xml-ph-0033@deep $items\
})
End try
return $newInvoice


No processo de criação deste exemplo, o programador não está preocupado com o local exato onde ocorre um erro. Ele quer apenas registar o erro e garantir que não criou dados inválidos.
A função recebe como parâmetros a entidade cliente, a coleção de itens e a referência à fatura.
Uma transação começa no início para proteger a integridade dos dados durante o processo de criação.
Todo o código de criação é protegido num bloco de código Try.
Se a fatura e as linhas de fatura tiverem sido criadas sem erros, a transação é validada no final do bloco de código Try.
Mas se ocorrer um erro, o bloco de código Catch é executado onde quer que ele tenha ocorrido no bloco de código Try. No bloco de código Catch, a transação é cancelada e o erro é registado por uma função personalizada.

Blocos de código Try-Catch em detalhes

Para proteger a execução de um bloco de código contra a exibição de uma caixa de diálogo de erro 4D, pode agora rodeá-lo com as palavras-chave Try e End try.
O tratamento de erros não é obrigatório, mas é melhor! Assim, pode agora inserir uma palavra-chave Catch antes da palavra-chave End try e escrever o código de tratamento de erros em várias linhas entre as palavras-chave Catch e End try. Esta prática é comum noutras linguagens e torna os métodos/funções longos mais fáceis de ler!

Quando nenhum erro for encontrado durante a execução do bloco de código Try, o código salta o bloco de código Catch, se existir, e continua após a palavra-chave End try.
Mas quando um erro for acionado por qualquer linha de código no bloco de código Try:

1. Se instalado, o manipulador de erro atual não é chamado.
2. A caixa de diálogo de erro 4D não é exibida.
3. O erro é adicionado à pilha de erros atual.
4. A execução do código muda imediatamente para o bloco de código Catch. Se a palavra-chave Catch estiver faltando, a execução do código pula imediatamente após a palavra-chave End try correspondente.

Observe que se nenhum manipulador de erro for definido para o contexto de execução atual e um erro for acionado durante a execução do bloco de código Catch, a caixa de diálogo de erro 4D é exibida. Mas também pode utilizar Try(Expression) ou blocos de código Try-Catch aninhados para evitar a apresentação da caixa de diálogo de erro 4D!

Sobre a pilha de erros

Antes que a primeira linha do bloco de código Try seja executada, a pilha de erros atual é limpa. Esse comportamento é benéfico na maioria dos casos, já que não é necessário comparar a pilha de erros antes e depois da execução para detectar novos erros.
Portanto, se você deseja inserir um bloco de código Try-Catch em um bloco de código Catch e recuperar toda a pilha de erros, não se esqueça de armazená-la previamente em uma coleção, como neste exemplo:

var $errors : Collection
Try
throw (123; "Primeiro erro")
Catch
$errors .push(Last errors)
Try
throw (456; "Segundo erro")
Catch
$errors .push(Last errors)
// $errors coleção contém os dois erros prévios
End try
End try

Mistura com o tratamento global de erros

O tratamento de erros usando o comando ON ERR CALL ainda é relevante hoje em dia. Pode ser utilizado eficazmente com os blocos de código Try(Expression) e Try-Catch. Basta ter em mente a prioridade do tratamento de erros:

1. Try(Expression). Este é o método mais preciso, pois permite-lhe verificar a existência de erros numa única linha.
2. Blocos de código Try-Catch. Esta é a melhor forma de proceder quando se considera irrelevante a verificação de erros linha a linha.
3. ON ERR CALL comando com a opção padrão ek local para detectar erros não gerenciados na próxima execução de código no processo/trabalhador atual.
4. ON ERR CALL comando com as opções ek global e ek errors from components para detectar erros sempre que um sistema de tratamento de erros não tenha sido instalado ou codificado.

Não se esqueça de que as principais vantagens de codificar o tratamento de erros com blocos de código Try(Expression) ou Try-Catch são

• colocar o tratamento de erros o mais próximo possível do código que gera os erros
• utilizar variáveis locais no código de tratamento de erros

Agora tem todas as cartas na mão para tratar os erros como quiser, tornando o seu código mais seguro!

Esforçamo-nos para fornecer a nossos usuários a melhor experiência possível, e encorajamos a compartilhar seus pensamentos e comentários no fórum 4D. Seu feedback nos ajuda a entender suas necessidades e melhorar continuamente nossos produtos e serviços.
Boa codificação!