Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Datenübergabe an asynchrone Methoden
<a name="advanceddatapassing"></a>

**Topics**
+ [Übergabe von Collections und Maps an asynchrone Methoden](#advanceddatapassing.collections)
+ [Einstellbare <T>](#advanceddatapassing.settable)
+ [@NoWait](#advanceddatapassing.nowait)
+ [Promise <Void>](#advanceddatapassing.promise)
+ [AndPromise und OrPromise](#advanceddatapassing.andorpromise)

Die Verwendung von `Promise<T>` wurde in den vorangegangenen Abschnitten erläutert. Hier werden einige fortgeschrittene Anwendungsfälle von `Promise<T>` besprochen.

## Übergabe von Collections und Maps an asynchrone Methoden
<a name="advanceddatapassing.collections"></a>

Das Framework unterstützt die Übergabe von Arrays, Collections und Maps als `Promise`-Typen an asynchrone Methoden. Beispielsweise kann eine asynchrone Methode, wie im Folgenden gezeigt, `Promise<ArrayList<String>>` als Argument entgegennehmen.

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

Semantisch verhält sich diese Variante wie jeder andere typisierte `Promise`-Parameter und die asynchrone Methode wartet, bis die Collection verfügbar wird, bevor sie ausgeführt wird. Wenn die Mitglieder einer Collection `Promise`-Objekte sind, können Sie das Framework warten lassen, bis alle Mitglieder bereit sind. Dies ist im folgenden Snippet zu sehen. Dadurch wartet die asynchrone Methode auf die Verfügbarkeit aller Mitglieder der Collection.

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

 Beachten Sie, dass die `@Wait`-Annotation für den Parameter verwendet werden muss. Diese zeigt an, das `Promise`-Objekte enthalten sind. 

 Beachten Sie außerdem, dass die Aktivität `printActivity` ein `String`-Argument entgegennimmt, die entsprechende Methode im generierten Client jedoch ein Promise<String>-Argument erwartet. Wir rufen die Methode für den Client auf. Wir rufen nicht die Aktivitätsmethode direkt auf. 

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

`Settable<T>` ist ein von `Promise<T>` abgeleiteter Typ, der eine Set-Methode zur Verfügung stellt, mit der Sie den `Promise`-Wert manuell einstellen können. Beispielsweise wartet der folgende Workflow auf den Empfang eines Signals, indem er auf ein `Settable<?>` wartet, das in der Signalmethode festgelegt ist:

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

Ein `Settable<?>`-Wert kann außerdem mit einem anderen Promise-Objekt verkettet werden. Mit `AndPromise` und `OrPromise` können Sie Promise-Objekte gruppieren. Sie können die Verkettung eines verketteten `Settable` aufheben, indem Sie die `unchain()`-Methode aufrufen. Wenn eine Verkettung vorhanden ist, steht `Settable<?>` automatisch bereit, wenn das verkettete Promise-Objekt bereit ist. Die Verkettung ist besonders dann nützlich, wenn Sie ein im Rahmen eines `doTry()`-Aufrufes zurückgegebenes Promise-Objekt in anderen Teilen Ihres Programms verwenden wollen. Da `TryCatchFinally` es sich um eine verschachtelte Klasse handelt, können Sie a nicht `Promise<>` im Gültigkeitsbereich des übergeordneten Objekts deklarieren und festlegen. `doTry()` Dies liegt daran, dass in Java Variablen im übergeordneten Bereich deklariert und in verschachtelten Klassen verwendet werden müssen, um als endgültig markiert zu werden. Beispiel:

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

Ein `Settable` kann jeweils mit einem Promise-Objekt verkettet werden. Sie können die Verkettung eines verketteten `Settable` aufheben, indem Sie die `unchain()`-Methode aufrufen.

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

Wenn Sie ein `Promise` an eine asynchrone Methode übergeben, wartet das Framework standardmäßig, bis die `Promise`(s) bereit sind, bevor es die Methode ausführt (außer bei Collection-Typen). Sie können dieses Verhalten überschreiben, indem Sie in der Deklaration der asynchronen Methode die `@NoWait`-Notation für die Parameter verwenden. Dies ist dann nützlich, wenn Sie in `Settable<T>` Werte übergeben, die durch die asynchrone Methode selbst festgelegt werden.

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

Abhängigkeiten in asynchronen Methoden werden implementiert, indem das von einer Methode zurückgegebene `Promise`-Objekt als Argument an eine andere Methode übergeben wird. Es kann jedoch Fälle geben, in denen Sie aus einer Methode einen `void`-Wert zurückgeben möchten, aber dennoch andere asynchrone Methoden nach ihrer Beendigung ausführen möchten. In solchen Fällen können Sie `Promise<Void>` als Rückgabetyp der Methode verwenden. Die Klasse `Promise` stellt eine statische `Void`-Methode zur Verfügung, mit der Sie ein `Promise<Void>`-Objekt anlegen können. Dieses `Promise`-Objekt ist dann bereit, wenn die asynchrone Methode die Ausführung beendet. Sie können das `Promise` wie jedes andere `Promise`-Objekt an eine andere asynchrone Methode übergeben. Wenn Sie `Settable<Void>` verwenden, dann rufen Sie zur Bereitstellung dessen Set-Methode mit "null" auf.

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

Mit `AndPromise` und `OrPromise` können Sie mehrere `Promise<>`-Objekte zu einem einzigen logischen Promise-Objekt zusammenfassen. Ein `AndPromise` ist dann bereit, wenn alle zur Erstellung verwendeten Promise-Objekte bereit sind. Ein `OrPromise` ist dann bereit, wenn alle Promise-Objekte in der zur Erstellung verwendeten Promise-Collection bereit sind. Sie können `getValues()` für `AndPromise` und `OrPromise` aufrufen, um die Werteliste der einzelnen Promise-Objekte abzurufen.