Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Passaggio di dati a metodi asincroni
<a name="advanceddatapassing"></a>

**Topics**
+ [Passaggio di raccolte e mappe a metodi asincroni](#advanceddatapassing.collections)
+ [impostabile <T>](#advanceddatapassing.settable)
+ [@NoWait](#advanceddatapassing.nowait)
+ [Promise <Void>](#advanceddatapassing.promise)
+ [AndPromise e OrPromise](#advanceddatapassing.andorpromise)

L'utilizzo di `Promise<T>` è stato descritto nelle sezioni precedenti. In questa, vengono presentati alcuni casi d'uso avanzati di `Promise<T>`.

## Passaggio di raccolte e mappe a metodi asincroni
<a name="advanceddatapassing.collections"></a>

Il framework supporta il passaggio di matrici, raccolte e mappe come tipi `Promise` a metodi asincroni. Ad esempio, un metodo asincrono può accettare `Promise<ArrayList<String>>` come argomento come mostrato nel listato seguente.

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

Sul piano semantico, il comportamento è quello di qualsiasi altro parametro di tipo `Promise` e il metodo asincrono attenderà fino a che la raccolta diventa disponibile prima di avviare l'esecuzione. Se i membri di una raccolta sono oggetti `Promise`, il framework può attendere che tutti i membri diventino pronti come mostrato nel frammento seguente. In questo modo, il metodo asincrono attende che ogni membro della raccolta diventi disponibile.

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

 Nota che l'annotazione `@Wait` deve essere utilizzata nel parametro per indicare che contiene oggetti `Promise`. 

 Considera inoltre che l'attività `printActivity` accetta un argomento `String` ma il metodo corrispondente nel client generato accetta Promise<String>. Stiamo chiamando il metodo sul client e non richiamando il metodo dell'attività direttamente. 

## impostabile <T>
<a name="advanceddatapassing.settable"></a>

`Settable<T>` è un tipo derivato di `Promise<T>` che fornisce un metodo set con cui impostare manualmente il valore di un oggetto `Promise`. Ad esempio, il seguente flusso di lavoro attende la ricezione di un segnale attendendo `Settable<?>`, impostato nel metodo del segnale:

```
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;
   }
}
```

`Settable<?>` può inoltre essere concatenato a un'altra promessa alla volta. Puoi utilizzare `AndPromise` e `OrPromise` per raggruppare le promesse. Puoi annullare la concatenazione di `Settable` chiamando il metodo `unchain()`. Quando concatenato, `Settable<?>` diventa automaticamente pronto quando la promessa a cui è concatenato diventa pronta. La concatenazione è particolarmente utile quando desideri utilizzare una promessa restituita dall'ambito di un metodo `doTry()` in altre parti del programma. Poiché `TryCatchFinally` viene utilizzata come classe annidata, non è possibile dichiarare una `Promise<>` nell'ambito del genitore e impostarla. `doTry()` Questo perché Java richiede variabili che devono essere dichiarate nell'ambito padre e utilizzate in classi nidificate per essere contrassegnate come final. Esempio:

```
@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;
}
```

`Settable` può essere concatenato a una promessa alla volta. Puoi annullare la concatenazione di `Settable` chiamando il metodo `unchain()`.

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

Quando passi un oggetto `Promise` a un metodo asincrono, per impostazione predefinita il framework attende che gli oggetti `Promise` diventino pronti prima di eseguire il metodo (ad eccezione dei tipi di raccolta). Puoi eseguire l'override di questo comportamento utilizzando l'annotazione `@NoWait` sui parametri nella dichiarazione del metodo asincrono. Ciò è utile se passi `Settable<T>`, che verrà impostato dal metodo asincrono stesso.

## Promise <Void>
<a name="advanceddatapassing.promise"></a>

Le dipendenze nei metodi asincroni sono implementate passando l'oggetto `Promise` restituito da un metodo come argomento a un altro metodo. Possono tuttavia esserci casi in cui vuoi che un metodo restituisca `void` e che altri metodi asincroni siano eseguiti dopo il completamento di quel metodo. Per quei casi, puoi utilizzare `Promise<Void>` come tipo restituito del metodo. La classe `Promise` fornisce un metodo `Void` statico che puoi utilizzare per creare un oggetto `Promise<Void>`. Questo oggetto `Promise` diventerà pronto al termine dell'esecuzione del metodo asincrono. Puoi passare questo oggetto `Promise` a un altro metodo asincrono come qualsiasi altro oggetto `Promise`. Se utilizzi `Settable<Void>`, chiama il metodo set con null per renderlo pronto.

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

`AndPromise` e `OrPromise` ti consentono di raggruppare molteplici oggetti `Promise<>` in un'unica promessa logica. Un oggetto `AndPromise` diventa pronto quanto tutte le promesse utilizzate per costruirlo diventano pronte. Un oggetto `OrPromise` diventa pronto quando qualsiasi promessa nella raccolta di promesse utilizzata per costruirla diventa pronta. Puoi chiamare `getValues()` su `AndPromise` e `OrPromise` per recuperare l'elenco di valori delle promesse costituenti.