Histórico da Página
Um bloco de código entre as expressões Try...Catch são testados e caso de um erro implícito no código (uma exceção), ou erro explicito declarado no programa, tem seu fluxo desviado para o bloco de tratamento de erro em catch.
Diferente do BEGIN SEQUENCE ... END SEQUENCE, onde o código dispara o bloco de erros e pode continuar sua execução sem cair no RECOVER, apenas mediante ao comando o BREAK, uma exceção no código, mesmo que de forma implícita (por exemplo, a utilização de uma classe não definida), irá imediatamente desviar o fluxo de código para o bloco de tratamento de erro.
Outra diferença é que a captura do erro ocorre via a classe ErrorClass(), que pode ou não ter sido definida durante a execução do programa, e conterá em seus parâmetros o conteúdo do erro informado.
Informações |
---|
Apesar do TRY...CATCH só estar disponível no TLPP, ainda é possível realizar um THROW, implícito ou explicito a partir de uma chamada para uma função em advpl dentro de seu bloco de código. |
01. SINTAXE
Bloco de código | ||
---|---|---|
| ||
TRY ...
< instruções >
...
[ THROW [ < expressão > ] ]
...
< instruções >
...
[ RECOVER [ USING < variável > ] ]
...
< instruções >
...
CATCH
< instruções >
FINALLY
< instruções >
ENDTRY |
02. PARÂMETROS
Nome | Tipo | Descrição | Obrigatório | Referência |
---|
03. RETORNO
Nome
Tipo
Descrição
04. OBSERVAÇÕES
05. EXEMPLOS
theme | Eclipse |
---|
06. ABRANGÊNCIA
07. NESSA SEÇÃO
Page Tree | ||||||
---|---|---|---|---|---|---|
|
nopanel | true |
---|
TRY | Expressão | Define o inicio do bloco de código contendo o controle de erro | Sim | Não |
THROW [ < expressão > ] | Expressão | Define um desvio explicito para o tratamento de erro | Não | Sim |
CATCH | Expressão | Define um ponto de tratamento de erro e/ou recuperação que será o ponto de desvio em caso de erro no bloco do TRY | Sim | Não |
FINALLY | Expressão | Define um bloco de código que será executado de qualquer maneira(se tiver ou não tiver exceção lançada) | Não | Não |
ENDTRY | Expressão | Define o fim do bloco de sequência | Sim | Não |
03. EXEMPLOS
Um dos modelos mais simples de exemplo que temos, é onde realizamos um throw explicito em nosso programa. Isso faz com que, indifente do nível do stack onde estamos no nosso programa, ele vai mudar imediatamente o fluxo do programa para o CATCH, e informar a ultima descrição de erro erro (varError:description) informada:
Bloco de código | ||
---|---|---|
| ||
function u_fTryT01()
conout("funcao que cria o errorclass")
varError := ErrorClass():New() //sempre a exceção lançada deve ser uma instância da classe ErrorClass ou de uma classe que herda de ErrorClass
varError:genCode := 15461
varError:description := "ERRO designado no ErrorClass do u_fTryT01"
throw varError //lançamento da exceção com objeto de erro
conout("NÃO PODE PASSAR NUNCA") //nunca passará nesse trecho de código porque tem uma exceção lançada na linha anterior
return
User Function TryC001
Local x
Local y := "TryTest"
TRY
//ErrorClass pode ou não ser declarado no mesmo nível
//Local oError := ErrorClass():New()
u_fTryT01()
conout("essa linha NÃO deve ser executada (throw explicito dentro do u_fTryT01())")
x := &y.(,)
CATCH oError
ConOut( oError:description )
ENDTRY
Return( NIL ) |
Uma observação importante ao declarar a ErrorClass em outro nível de stack, é o seu escopo. Observe o exemplo abaixo:
Bloco de código |
---|
function u_fTryT02p()
conout("funcao que cria o errorclass como publica (vai funcionar)")
public varError := ErrorClass():New() //sempre a exceção lançada deve ser uma instância da classe ErrorClass ou de uma classe que herda de ErrorClass
varError:genCode := 15461
varError:description := "ERRO DO u_fTryT02p"
return
User Function TryC002
TRY
//se eu declarar como local, e nao public, vai dar erro no varerror dentro do catch..
u_fTryT02p()
throw varError
conout("NÃO PODE PASSAR NUNCA") //nunca passará nesse trecho de código porque tem uma exceção lançada na linha anterior
CATCH varError
//ConOut( ProcName() + " " + Str(ProcLine()) + " " + e:description )
ConOut( varError:description )
ENDTRY
Return( NIL ) |
Nesse caso o throw explicito foi realizado em outro nivel de stack onde ocorreu a declaração da instancia da ErrorClass. Porem como foi declarado como publica, não houve problema. Diferentemente do exemplo abaixo:
Bloco de código |
---|
function u_fTryT02()
conout("funcao que cria o errorclass como local (NÃO vai funcionar)")
varError := ErrorClass():New() //sempre a exceção lançada deve ser uma instância da classe ErrorClass ou de uma classe que herda de ErrorClass
varError:genCode := 15461
varError:description := "ERRO DO u_fTryT02"
return
User Function TryC0002
TRY
//se eu declarar como local, e nao public, vai dar erro no varerror dentro do catch..
u_fTryT02()
throw varError
conout("NÃO PODE PASSAR NUNCA") //nunca passará nesse trecho de código porque tem uma exceção lançada na linha anterior
CATCH varError
conout("conout aqui vai mostrar errado, como 'varError nao existe', e nao como 'ERRO DO u_fTryT02'")
ConOut( varError:description )
ENDTRY
Return( NIL ) |
Aqui o erro capturado será na linha do THROW varError, e não a informação declarada no stack anterior, ja que nesse ponto do stack a instancia varError não existe.
Outro exemplo simples de utilização é com a captura de erros de forma implícita, por conta de exceções na linguagem. Veja o exemplo onde a função TryTest não existe em nosso RPO:
Bloco de código |
---|
User Function TryC003
Local x
Local y := "TryTest"
TRY
u_fTryT02p()
x := &y.(,)
conout("NÃO PODE PASSAR NUNCA") //nunca passará nesse trecho de código porque tem uma exceção lançada na linha anterior
CATCH oError
ConOut( oError:description )
ENDTRY
Return( NIL ) |
Nesse exemplo mesmo com a classe declarada varError na função , o conout da oError será "Macro FC: cannot find function :TryTest". Observe também que apesar de não existir a instancia declara de oError, mesmo assim a chamada de CATCH a essa instancia foi preenchida com a instancia padrão de ErrorClass() que existe no AppServer, isso considerando que o erro foi implícito, e não explicito como na chamada de THROW varError de um exemplo anterior.
Para ficar claro a questão de erros explicitos e implicitos, observe no proximo exemplo onde mesmo informando uma descrição a instancia oError, a informação do conout é do erro implícito:
Bloco de código |
---|
User Function TryC0003
Local x
Local y := "TryTest"
TRY
oError := ErrorClass():New()
oError:genCode := 15461
oError:description := "ERRO designado no ErrorClass do u_TryC0003"
x := &y.(,)
conout("NÃO PODE PASSAR NUNCA") //nunca passará nesse trecho de código porque tem uma exceção lançada na linha anterior
CATCH oError
ConOut( oError:description )
ENDTRY
Return( NIL ) |
04. ABRANGÊNCIA
Application Server 19.3.2.0
Templatedocumentos
HTML |
---|
<style> div.theme-default .ia-splitter #main { margin-left: 0px; } .ia-fixed-sidebar, .ia-splitter-left { display: none; } table { border: 1px solid; } .syntaxhighlighter { overflow: initial; } #main { padding-left: 10px; padding-right: 10px; overflow-x: hidden; } .aui-header-primary .aui-nav, .aui-page-panel { margin-left: 0px !important; } .aui-header-primary .aui-nav { margin-left: 0px !important; } </style> |