As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Passagem de dados para métodos assíncronos
**Topics**
+ [Passagem de coleções e mapas para métodos assíncronos](#advanceddatapassing.collections)
+ [definíveis ](#advanceddatapassing.settable)
+ [@NoWait](#advanceddatapassing.nowait)
+ [Promessa ](#advanceddatapassing.promise)
+ [AndPromise and OrPromise](#advanceddatapassing.andorpromise)
O uso da `Promise<{{T}}>` foi explicado nas seções anteriores. Alguns casos de uso avançados da `Promise<{{T}}>` são discutidos aqui.
## Passagem de coleções e mapas para métodos assíncronos
A estrutura oferece suporte à passagem de matrizes, coleções e mapas como tipos `Promise` para métodos assíncronos. Por exemplo, um método assíncrono pode usar `Promise>` como um argumento, conforme mostrado na lista a seguir.
```
@Asynchronous
public void printList(Promise> list) {
for (String s: list.get()) {
activityClient.printActivity(s);
}
}
```
Semanticamente, isso se comporta como qualquer outro parâmetro de tipo `Promise`, e o método assíncrono esperará até que a coleção se torne disponível antes de executar. Se os membros de uma coleção forem objetos `Promise`, você poderá fazer com que a estrutura espere que todos os membros se tornem prontos, conforme mostrado no trecho de código a seguir. Isso fará com que o método assíncrono espere que cada membro da coleção se torne disponível.
```
@Asynchronous
public void printList(@Wait List> list) {
for (Promise s: list) {
activityClient.printActivity(s);
}
}
```
Observe que a anotação `@Wait` deve ser usada no parâmetro para indicar que contém objetos `Promise`.
Observe também que a atividade `printActivity` usa o argumento `String`, mas o método correspondente no cliente gerado usa uma Promise. Estamos chamando o método no cliente e não estamos invocando o método da atividade diretamente.
## definíveis
`Settable<{{T}}>` é um tipo derivado de `Promise` que fornece um método de definição que permite definir manualmente o valor de uma `Promise`. Por exemplo, o fluxo de trabalho a seguir espera que um sinal seja recebido aguardando em um `Settable`, que é definido no método de sinal:
```
public class MyWorkflowImpl implements MyWorkflow{
final Settable result = new Settable();
//@Execute method
@Override
public Promise start() {
return done(result);
}
//Signal
@Override
public void manualProcessCompletedSignal(String data) {
result.set(data);
}
@Asynchronous
public Promise done(Settable result){
return result;
}
}
```
Uma `Settable` também pode ser encadeada em outra promessa de cada vez. Você pode usar `AndPromise` e `OrPromise` para agrupar promessas. Você pode desencadear uma `Settable` encadeada chamando o método `unchain()` nela. Quando encadeada, a `Settable` se torna pronta automaticamente quando a promessa encadeada se torna pronta. O encadeamento é especialmente útil quando você deseja usar uma promessa retornada do escopo de um `doTry()` em outras partes de seu programa. Como `TryCatchFinally` é usada como uma classe aninhada, você não pode declarar a `Promise<>` no escopo do pai e configurá-la. `doTry()` Isso acontece porque o Java exige que as variáveis sejam declaradas no escopo pai e usadas em classes aninhadas para serem marcadas finais. Por exemplo:
```
@Asynchronous
public Promise chain(final Promise input) {
final Settable result = new Settable();
new TryFinally() {
@Override
protected void doTry() throws Throwable {
Promise 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;
}
```
Uma `Settable` pode ser encadeada para uma promessa de cada vez. Você pode desencadear uma `Settable` encadeada chamando o método `unchain()` nela.
## @NoWait
Quando você passa uma `Promise` para um método assíncrono, por padrão, a estrutura aguardará que a(s) `Promise`(s) se torne(m) pronta(s) antes de executar o método (exceto para tipos de coleção). Você pode substituir esse comportamento usando a anotação `@NoWait` em parâmetros na declaração do método assíncrono. Isso será útil se você estiver passando `Settable` que será definido pelo próprio método assíncrono.
## Promessa
As dependências de métodos assíncronos são implementadas passando a `Promise` retornada por um método como um argumento para outro. Contudo, pode haver casos em que você deseje retornar `void` de um método, mas ainda deseje que outros métodos assíncronos sejam executados após a conclusão. Nesses casos, você pode usar `Promise` como o tipo de retorno do método. A classe `Promise` fornece um método `Void` estático que pode ser usado para criar um objeto de `Promise`. Essa `Promise` se tornará pronta quando o método assíncrono concluir a execução. Você pode passar essa `Promise` para outro método assíncrono como qualquer outro objeto de `Promise`. Se você estiver usando `Settable`, chame o método set nele com null para torná-lo pronto.
## AndPromise and OrPromise
`AndPromise` e `OrPromise` permitem que você agrupe vários objetos `Promise<>` em uma única promessa lógica. Uma `AndPromise` torna-se pronta quando todas as promessas usadas para construí-la se tornarem prontas. Uma `OrPromise` torna-se pronta quando qualquer promessa na coleção de promessas usadas para construí-la se tornarem prontas. Você pode chamar `getValues()` em `AndPromise` e `OrPromise` para recuperar a lista de valores das promessas constituintes.