MethodHandles.TryFinally(MethodHandle, MethodHandle) Méthode

[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.MethodHandle

Paramètres

Retours

un handle de méthode qui incarne le try-finally bloc composé des deux arguments.

Attributs

RegisterAttribute

Remarques

Crée un handle de méthode qui adapte un target handle de méthode en encapsulant-le dans un try-finally bloc. Un autre handle de méthode, cleanupreprésente les fonctionnalités du finally bloc. Toute exception levée pendant l’exécution du target handle est passée au cleanup handle. L’exception est réinitie, sauf si cleanup le handle lève d’abord une exception. La valeur retournée à partir de l’exécution cleanup du handle est le résultat de l’exécution try-finally du handle.

Le cleanup handle est passé un ou deux arguments de début supplémentaires. La première est l’exception levée pendant l’exécution du target handle, ou null si aucune exception n’a été levée. Le deuxième est le résultat de l’exécution du target handle, ou, s’il lève une exception, un null, zéro ou false valeur du type requis est fourni en tant qu’espace réservé. Le deuxième argument n’est pas présent si le target handle a un void type de retour. (Notez que, à l’exception des conversions de types d’arguments, les combinateurs représentent void des valeurs dans les listes de paramètres en omettant les arguments paradoxaux correspondants, et non en insérant null ou zéro valeurs.)

Les target handles et cleanup les handles doivent avoir les mêmes types d’argument et de retour correspondants, sauf que le cleanup handle peut omettre les arguments de fin. En outre, le cleanup handle doit avoir un ou deux paramètres de début supplémentaires :<ul><li>a Throwable, qui transportera l’exception levée par le target handle (le cas échéant) ; et <li>un paramètre du même type que le type de retour des deux target et cleanup, qui contiendra le résultat de l’exécution du target handle. Ce paramètre n’est pas présent si le target retour est retourné void. </ul>

Le pseudocode de l’adaptateur résultant se présente comme suit. Dans le code, V représente le type de résultat de la try/finally construction ; A/a, les types et les valeurs d’arguments utilisés par le handle résultant consommé par le nettoyage ; et B/b, ceux des arguments au handle résultant ignoré par le nettoyage. <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>

Notez que les arguments enregistrés (a... dans le pseudocode) ne peuvent pas être modifiés par l’exécution de la cible, et sont donc passés inchangés de l’appelant au nettoyage, s’il est appelé.

La cible et le nettoyage doivent retourner le même type, même si le nettoyage lève toujours. Pour créer un tel nettoyage de levée, composez la logique de nettoyage avec #throwException throwException, afin de créer un handle de méthode du type de retour correct.

Notez que tryFinally ne convertit jamais les exceptions en retour normal. Dans de rares cas où les exceptions doivent être converties de cette façon, encapsulez d’abord la cible avec #catchException(MethodHandle, Class, MethodHandle) pour capturer une exception sortante, puis encapsulez avec tryFinally.

Il est recommandé de déclarer Throwable le premier type de cleanup paramètre plutôt qu’un sous-type plus étroit. Cela garantit qu’elle cleanup sera toujours appelée à l’exception qui target lève. La déclaration d’un type plus étroit peut entraîner une ClassCastException levée par le try-finally handle si le type de l’exception levée par target n’est pas assignable au premier type de paramètre de cleanup. Notez que différents types d’exceptions de , et peuvent en principe être levées par presque n’importe quel type de code Java, et une clause enfin qui intercepte (disons) ne IOException masque que les autres derrière un ClassCastException.RuntimeExceptionLinkageErrorVirtualMachineError

Ajouté dans 9.

Java documentation pour java.lang.invoke.MethodHandles.tryFinally(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.