Try...Catch

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.

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

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
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:

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:

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:

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:

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:

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

05. VEJA TAMBÉM

BEGIN SEQUENCE ... END

Árvore de páginas