MethodHandles.TryFinally(MethodHandle, MethodHandle) Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Faz um identificador de método que adapta um target identificador de método encapsulando-o em um try-finally bloco.
[Android.Runtime.Register("tryFinally", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=33)]
public static Java.Lang.Invoke.MethodHandle? TryFinally(Java.Lang.Invoke.MethodHandle? target, Java.Lang.Invoke.MethodHandle? cleanup);[<Android.Runtime.Register("tryFinally", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=33)>]
static member TryFinally : Java.Lang.Invoke.MethodHandle * Java.Lang.Invoke.MethodHandle -> Java.Lang.Invoke.MethodHandleParâmetros
- target
- MethodHandle
o identificador cuja execução deve ser encapsulada em um try bloco.
- cleanup
- MethodHandle
o identificador que é invocado no bloco finalmente.
Retornos
um identificador de método que incorpora o try-finally bloco composto pelos dois argumentos.
- Atributos
Comentários
Faz um identificador de método que adapta um target identificador de método encapsulando-o em um try-finally bloco. Outro identificador de cleanupmétodo representa a funcionalidade do finally bloco. Qualquer exceção gerada durante a execução do target identificador será passada para o cleanup identificador. A exceção será relançada, a menos que o identificador cleanup gere uma exceção primeiro. O valor retornado da cleanup execução do identificador será o resultado da execução do try-finally identificador.
O cleanup identificador será passado um ou dois argumentos principais adicionais. A primeira é a exceção gerada durante a execução do target identificador ou null se nenhuma exceção foi lançada. O segundo é o resultado da execução do target identificador ou, se ele gerar uma exceção, um null, zero ou false valor do tipo necessário será fornecido como um espaço reservado. O segundo argumento não estará presente se o target identificador tiver um void tipo de retorno. (Observe que, com exceção das conversões de tipo de argumento, os combinadores representam void valores em listas de parâmetros omitindo os argumentos paradoxais correspondentes, não inserindo null ou zero valores.)
Os target identificadores e cleanup identificadores devem ter os mesmos tipos de argumento e retorno correspondentes, exceto que o cleanup identificador pode omitir argumentos à direita. Além disso, o cleanup identificador deve ter um ou dois parâmetros adicionais à esquerda:<ul<>li>aThrowable, que carregará a exceção gerada pelo target identificador (se houver); e <li>um parâmetro do mesmo tipo que o tipo de retorno de ambos target ecleanup, que levará o resultado da execução do target identificador. Esse parâmetro não estará presente se o target retorno for .void
</ul>
O pseudocódigo para o adaptador resultante tem a seguinte aparência. No código, V representa o tipo de resultado do try/finally constructo;/aA , os tipos e valores de argumentos para o identificador resultante consumido pela limpeza; e B/b, os argumentos para o identificador resultante descartados pela limpeza.
<blockquote>
{@code
V target(A..., B...);
V cleanup(Throwable, V, A...);
V adapter(A... a, B... b) {
V result = (zero value for V);
Throwable throwable = null;
try {
result = target(a..., b...);
} catch (Throwable t) {
throwable = t;
throw t;
} finally {
result = cleanup(throwable, result, a...);
}
return result;
}
}
</blockquote>
Observe que os argumentos salvos (a... no pseudocódigo) não podem ser modificados pela execução do destino e, portanto, são passados inalterados do chamador para a limpeza, se ele for invocado.
O destino e a limpeza devem retornar o mesmo tipo, mesmo que a limpeza sempre seja gerada. Para criar essa limpeza de lançamento, redigir a lógica de limpeza com #throwException throwException, a fim de criar um identificador de método do tipo de retorno correto.
Observe que tryFinally nunca converte exceções em retornos normais. Em casos raros em que as exceções devem ser convertidas dessa forma, primeiro encapsular o destino #catchException(MethodHandle, Class, MethodHandle) para capturar uma exceção de saída e, em seguida, encapsular com tryFinally.
É recomendável que o primeiro tipo de parâmetro seja declarado Throwable em vez de cleanup um subtipo mais estreito. Isso garante cleanup que sempre será invocado com qualquer exceção gerada target . Declarar um tipo mais estreito pode resultar em uma ClassCastException geração pelo try-finally identificador se o tipo da exceção gerada por target não for atribuível ao primeiro tipo de parâmetro.cleanup Observe que vários tipos de exceção de VirtualMachineError, LinkageErrore RuntimeException podem, em princípio, ser gerados por quase qualquer tipo de código Java, e uma cláusula finalmente que captura (digamos) apenas IOException mascararia qualquer um dos outros por trás de um ClassCastException.
Adicionado em 9.
Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.