Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Paso de datos a los métodos asíncronos
<a name="advanceddatapassing"></a>

**Topics**
+ [Paso de colecciones y mapas a métodos asíncronos](#advanceddatapassing.collections)
+ [Settable <T>](#advanceddatapassing.settable)
+ [@NoWait](#advanceddatapassing.nowait)
+ [Promise <Void>](#advanceddatapassing.promise)
+ [AndPromise y OrPromise](#advanceddatapassing.andorpromise)

El uso de `Promise<T>` se ha explicado en las secciones anteriores. Se tratan aquí algunos casos de uso avanzados de `Promise<T>`.

## Paso de colecciones y mapas a métodos asíncronos
<a name="advanceddatapassing.collections"></a>

El marco de trabajo admite el paso de matrices, colecciones y mapas como tipos `Promise` a métodos asíncronos. Por ejemplo, un método asíncrono puede tomar `Promise<ArrayList<String>>` como un argumento tal y como se muestra en la siguiente lista.

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

Semánticamente, actúa como cualquier otro parámetro escrito `Promise` y el método asíncrono esperará hasta que la colección esté disponible antes de la ejecución. Si los miembros de una colección son objetos `Promise`, entonces puede hacer que el marco de trabajo espere a que todos los miembros estén preparados tal y como se muestra en el siguiente fragmento de código. Esto hará que el método asíncrono espere hasta que cada miembro de la colección esté disponible.

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

 Tenga en cuenta que debe usarse la anotación `@Wait` en el parámetro para indicar que contiene objetos `Promise`. 

 Tenga en cuenta también que la actividad `printActivity` toma un argumento `String` pero el método correspondiente en el cliente generado toma una Promise<String>. Estamos llamando el método en el cliente y no invocando directamente el método de la actividad. 

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

`Settable<T>` es un tipo derivado de `Promise<T>` que proporciona un método establecido que le permite establecer manualmente el valor de una `Promise`. Por ejemplo, el siguiente flujo de trabajo espera la recepción de una señal esperando en `Settable<?>`, que se establece en el método de señal:

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

También se puede encadenar `Settable<?>` a otra promesa individualmente. Puede utilizar `AndPromise` y `OrPromise` para agrupar promesas. Puede desencadenar un objeto `Settable` encadenado llamando al método `unchain()` que hay en él. Cuando está encadenado, `Settable<?>` está listo automáticamente cuando la promesa a la que está encadenado está lista. El encadenado es especialmente útil cuando desea utilizar una promesa devuelta desde dentro del alcance de `doTry()` en otras partes de su programa. Como `TryCatchFinally` se usa como una clase anidada, no puedes declarar a `Promise<>` en el ámbito del padre y configurarla. `doTry()` Esto es porque Java requiere que las variables se declaren en el ámbito principal y se utilicen en clases anidadas para marcarlas como finales. Por ejemplo:

```
@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 `Settable` puede encadenarse a una promesa a cada vez. Puede desencadenar un objeto `Settable` encadenado llamando al método `unchain()` que hay en él.

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

Cuando pasa una `Promise` a un método asíncrono, de manera predeterminada, el marco de trabajo esperará a que la(s) `Promise`(s) estén listas antes de ejecutar el método (salvo para los tipos de colección). Puede anular este comportamiento utilizando la anotación `@NoWait` en parámetros en la declaración del método asíncrono. Esto es útil si está pasando `Settable<T>`, que será establecido por el método asíncrono.

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

Las dependencias en métodos asíncronos se implementan pasando la `Promise` devuelta por un método como argumento a otro. No obstante, hay casos en los que desea devolver `void` de un método, pero sigue queriendo que otros métodos asíncronos se ejecuten una vez finalizados. En esos casos, puede utilizar `Promise<Void>` como el tipo de retorno del método. La clase `Promise` proporciona un método `Void` estático que puede utilizar para crear un objeto `Promise<Void>`. Esta `Promise` estará lista cuando el método asíncrono finalice la ejecución. Puede pasar esta `Promise` a otro método asíncrono igual que cualquier otro objeto `Promise`. Si está utilizando `Settable<Void>`, entonces llame al método establecido en él con "null" para hacer que esté listo.

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

Con `AndPromise` y `OrPromise` puede agrupar múltiples objetos `Promise<>` en una sola promesa lógica. Una `AndPromise` está lista una vez que todas las promesas utilizadas para construirla están listas. Una `OrPromise` está lista una vez cuando cualquier promesa de la colección de promesas que se han utilizado para construirla está lista. Puede llamar a `getValues()` en `AndPromise` y `OrPromise` para recuperar la lista de valores de las promesas constituyentes.