Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Transmission des données aux méthodes asynchrones
<a name="advanceddatapassing"></a>

**Topics**
+ [Transmission des collections et des cartes aux méthodes asynchrones](#advanceddatapassing.collections)
+ [Définissable <T>](#advanceddatapassing.settable)
+ [@NoWait](#advanceddatapassing.nowait)
+ [Promets- <Vide>](#advanceddatapassing.promise)
+ [AndPromise et OrPromise](#advanceddatapassing.andorpromise)

L'utilisation de `Promise<T>` a été expliquée dans les sections précédentes. Certains cas d'utilisation avancés de `Promise<T>` sont présentés ici.

## Transmission des collections et des cartes aux méthodes asynchrones
<a name="advanceddatapassing.collections"></a>

L'infrastructure prend en charge la transmission des tableaux, collections et cartes comme types `Promise` vers des méthodes asynchrones. Par exemple, une méthode asynchrone peut prendre `Promise<ArrayList<String>>` comme un argument, comme illustré dans la liste suivante.

```
@Asynchronous
public void printList(Promise<List<String>> list) {
    for (String s: list.get()) {
        activityClient.printActivity(s);
    }
}
```

Sur le plan sémantique, cela se comporte comme tout autre paramètre de type `Promise` et la méthode asynchrone patientera jusqu'à ce que la collection soit disponible avant l'exécution. Si les membres d'une collection sont des objets `Promise`, alors vous pouvez faire patienter l'infrastructure jusqu'à ce que tous les membres soient prêts, comme illustré dans le code suivant. Cela fera patienter la méthode asynchrone jusqu'à ce que chaque membre de la collection soit disponible.

```
@Asynchronous
public void printList(@Wait List<Promise<String>> list) {
  for (Promise<String> s: list) {
      activityClient.printActivity(s);
  }
}
```

 Notez que l'annotation `@Wait` doit être utilisée sur le paramètre pour indiquer qu'il contient des objets `Promise`. 

 Notez également que l'activité `printActivity` prend un argument `String`, mais que la méthode correspondante dans le client généré prend le type Promise<String>. Nous appelons la méthode sur le client mais pas directement la méthode d'activité. 

## Définissable <T>
<a name="advanceddatapassing.settable"></a>

L'objet `Settable<T>` est un type dérivé d'un objet `Promise<T>` qui fournit une méthode qui vous permet de définir manuellement la valeur d'un objet `Promise`. Par exemple, le flux de travail suivant attend de recevoir un signal en attendant un objet `Settable<?>`, qui est définit dans la méthode de signal :

```
public class MyWorkflowImpl implements MyWorkflow{
   final Settable<String> result = new Settable<String>();

   //@Execute method
   @Override
   public Promise<String> start() {
      return done(result);
   }

   //Signal
   @Override
   public void manualProcessCompletedSignal(String data) {
      result.set(data);
   }

   @Asynchronous
   public Promise<String> done(Settable<String> result){
       return result;
   }
}
```

Un objet `Settable<?>` peut également être lié à un autre objet Promise à la fois. Vous pouvez utiliser les objets `AndPromise` et `OrPromise` pour regrouper les objets Promise. Vous pouvez délier un objet `Settable` lié en appelant la méthode `unchain()`. Une fois liés, les objets `Settable<?>` seront automatiquement prêts lorsque l'objet Promise lié sera prêt. L'action de lier est particulièrement utile lorsque vous souhaitez utiliser un objet Promise renvoyé depuis la portée d'un bloc `doTry()` dans d'autres parties de votre programme. Comme elle `TryCatchFinally` est utilisée comme classe imbriquée, vous ne pouvez pas déclarer un `Promise<>` dans le champ d'application du parent et le définir. `doTry()` Cela s'explique car Java exige que les variables soient déclarées dans la portée du parent et utilisées dans des classes imbriquées pour être marquées comme finales. Par exemple :

```
@Asynchronous
public Promise<String> chain(final Promise<String> input) {
    final Settable<String> result = new Settable<String>();

    new TryFinally() {

        @Override
        protected void doTry() throws Throwable {
            Promise<String> resultToChain = activity1(input);
            activity2(resultToChain);

            // Chain the promise to Settable
            result.chain(resultToChain);
        }

        @Override
        protected void doFinally() throws Throwable {
            if (result.isReady()) { // Was a result returned before the exception?
                // Do cleanup here
            }
        }
    };

    return result;
}
```

Un objet `Settable` peut également être lié à un seul objet Promise à la fois. Vous pouvez délier un objet `Settable` lié en appelant la méthode `unchain()`.

## @NoWait
<a name="advanceddatapassing.nowait"></a>

Lorsque vous transmettez un objet `Promise` à une méthode asynchrone, l'infrastructure attend que les objets `Promise` soient prêts avant d'exécuter la méthode (sauf pour les types de collection). Vous pouvez remplacer ce comportement à l'aide de l'annotation `@NoWait` sur les paramètres dans la déclaration de la méthode asynchrone. Cela est utile si vous transmettez `Settable<T>`, qui sera défini par la méthode asynchrone elle-même.

## Promets- <Vide>
<a name="advanceddatapassing.promise"></a>

Les dépendances dans les méthodes asynchrones sont implémentées en transmettant l'objet `Promise` renvoyé par une méthode en tant qu'argument à une autre méthode. Pourtant, il existe des cas où vous souhaitez renvoyer `void` depuis une méthode, mais souhaitez toujours que les autres méthodes asynchrone s'exécutent après la fin de celle-ci. Dans ces cas-là, vous pouvez utiliser le type `Promise<Void>` en tant que type de retour de la méthode. La classe `Promise` fournit une méthode `Void` statique que vous pouvez utiliser pour créer un objet `Promise<Void>`. Cet objet `Promise` sera prêt lorsque la méthode asynchrone terminera l'exécution. Vous pouvez transmettre cet objet `Promise` à une autre méthode asynchrone comme tout autre objet `Promise`. Si vous utilisez le type `Settable<Void>`, appelez ensuite la méthode de définition avec null pour la préparer.

## AndPromise et OrPromise
<a name="advanceddatapassing.andorpromise"></a>

Les objets `AndPromise` et `OrPromise` vous permettent de regrouper plusieurs objets `Promise<>` dans un objet Promise logique unique. Un objet `AndPromise` sera prêt lorsque tous les objets Promise utilisés pour le construire seront prêts. Un objet `OrPromise` sera prêt lorsque n'importe quel objet Promise de la collection d'objets Promise utilisés pour le construire sera prêt. Vous pouvez appeler `getValues()` sur les objets `AndPromise` et `OrPromise` pour récupérer la liste des valeurs des objets Promise qui les composent.