assíncrono e aguardar - pesquisa de alternativas [fechada]

Agora que sabemos o que está reservado para o c # 5, aparentemente ainda há uma abertura para influenciarmos a escolha das duas novas palavras-chave para ' Assíncronia ' que foram anunciadas ontem por Anders Heijsberg no PDC10 .

async void ArchiveDocuments(List<Url> urls) {
    Task archive = null;
    for(int i = 0; i < urls.Count; ++i) {
        var document = await FetchAsync(urls[i]);
        if (archive != null)
            await archive;
        archive = ArchiveAsync(document);
    }
}

Eric Lippert tem uma explicação sobre a escolha das duas palavras-chave atuais e a maneira como elas foram mal interpretadas nos estudos de usabilidade. Os comentários têm várias outras proposições.

Por favor - uma sugestão por resposta, duplicatas serão bloqueadas.

Dado que não sou claro sobre o significado / necessidade de async, não posso discutir com isso, mas minha melhor sugestão para substituir awaité:

yield while (veja! sem novas palavras-chave)

Note que, pensando um pouco mais sobre isso, pergunto-me se reutilizar whiledessa maneira é uma boa idéia - a tendência natural seria esperar um boleano posteriormente.

(Pensa: encontrar boas palavras-chave é como encontrar bons nomes de domínio :)

Que tal não ter uma palavra-chave?

Gostaria que o compilador percebesse que, na maioria das vezes, quando chamo um método assíncrono, quero o resultado.

Document doc = DownloadDocumentAsync();

É isso aí. A razão pela qual as pessoas estão tendo dificuldade em pensar em uma palavra-chave para isso é porque é como ter uma palavra-chave para "faça o que você faria se as coisas fossem perfeitamente normais". Esse deve ser o padrão, não requer uma palavra-chave.

Atualizar

Originalmente, sugeri que o compilador deveria ficar esperto com a inferência de tipo para descobrir o que fazer. Pensando mais sobre isso, eu manteria a implementação existente no CTP como ela é, mas faria algumas adições triviais, para reduzir os casos em que você precisaria usar a awaitpalavra - chave explicitamente.

Nós inventamos um atributo: [AutoAwait]. Isso só pode ser aplicado a métodos. Uma maneira de aplicar isso ao seu método é marcá-lo async. Mas você também pode fazer isso manualmente, por exemplo:

[AutoAwait]
public Task<Document> DownloadDocumentAsync()

Então, dentro de qualquer asyncmétodo, o compilador assumirá que você deseja aguardar uma chamada DownloadDocumentAsync, para que você não precise especificá-lo. Qualquer chamada para esse método o aguardará automaticamente.

Document doc = DownloadDocumentAsync();

Agora, se você deseja "ficar esperto" e obter o Task<Document>, use um operador start, que só pode aparecer antes de uma chamada de método:

Task<Document> task = start DownloadDocumentAsync();

Legal, eu acho. Agora, uma chamada simples de método significa o que normalmente significa: aguarde a conclusão do método. E startindica algo diferente: não espere.

Para o código que aparece fora de um asyncmétodo, a única maneira de você chamar um [AutoAwait]método é prefixando-o start. Isso obriga a escrever um código com o mesmo significado, independentemente de ele aparecer asyncou não em um método.

Então eu começo a ficar ganancioso! :)

Em primeiro lugar, quero asyncaplicar aos métodos de interface:

interface IThing
{
    async int GetCount();
} 

Basicamente, significa que o método de implementação deve retornar Task<int>ou algo compatível awaite os chamadores do método terão [AutoAwait]comportamento.

Além disso, quando eu implemento o método acima, desejo poder escrever:

async int GetCount()

Portanto, não tenho que mencionar Task<int>como o tipo de retorno.

Além disso, quero asyncaplicar a tipos de delegação (que, afinal, são como interfaces com um método). Então:

public async delegate TResult AsyncFunc<TResult>();

Um asyncdelegado tem - você adivinhou - [AutoAwait]comportamento. A partir de um asyncmétodo, você pode chamá-lo e ele será awaiteditado automaticamente (a menos que você escolha apenas start). E então, se você disser:

AsyncFunc<Document> getDoc = DownloadDocumentAsync;

Isso simplesmente funciona. Não é uma chamada de método. Nenhuma tarefa foi iniciada ainda - uma async delegatenão é uma tarefa. É uma fábrica para fazer tarefas. Você pode dizer:

Document doc = getDoc();

E isso iniciará uma tarefa, esperará que ela termine e dê o resultado. Ou você pode dizer:

Task<Document> t = start getDoc();

Portanto, um lugar onde o "encanamento" vaza é que, se você deseja fazer um delegado para um asyncmétodo, precisa saber usar um async delegatetipo. Então, em vez de Funcvocê deve dizer AsyncFunc, e assim por diante. Embora um dia esse tipo de coisa possa ser corrigido por inferência de tipo aprimorada.

Outra pergunta é o que deveria acontecer se você disser iniciar em um método comum (não assíncrono). Obviamente, um erro de compilação seria a opção segura. Mas existem outras possibilidades.

hearken unto AsyncFetch(…)

(se você não conseguir, leia a entrada do blog de Eric . Pelo menos é melhor que for sooth Romeo wherefore art thou AsyncFetch(…))

Eu acho que asyncestá bem, mas talvez seja porque eu o associo a páginas assíncronas do ASP.NET - a mesma idéia.

Para a awaitpalavra - chave eu prefiro continue afterou resume after.

Eu não como yieldou qualquer de suas variantes, porque a semântica são tais que o método pode nunca realmente deu execução; isso depende do estado da tarefa.

Também adicionei comentários ao blog de Eric, não vejo problemas ao usar a mesma palavra-chave async

var data = async DownloadFileAsync(url);

Estou apenas expressando que quero baixar o arquivo de forma assíncrona. Há um pouco de redundância aqui, "async" aparece duas vezes, porque também está no nome do método. O compilador pode ser mais inteligente e detectar a convenção de que os métodos que terminam em "Async" são métodos assíncronos de fato e acrescentam isso para nós no código compilado. Então, em vez disso, você pode querer ligar

var data = async DownloadFile(url);

em vez de chamar o síncrono

var data = DownloadFile(url);

Caramba, também devemos poder defini-los da mesma maneira, já que a palavra-chave assíncrona está presente em nossa declaração, por que devemos adicionar manualmente "Async" a cada nome de método - o compilador pode fazer isso por nós.

async = task - Está modificando uma função para retornar uma tarefa. Por que não usar a palavra-chave "task"?

waitit = finish - Não precisamos necessariamente esperar, mas a tarefa precisa "terminar" antes de usar o resultado.

Eu gosto yield until. yield while, já sugerido, é ótimo e não apresenta novas palavras-chave, mas acho que "até" captura o comportamento um pouco melhor.

Eu acho que yield <something>é uma ótima idéia, porque o rendimento já captura a idéia de tornar o restante do método uma continuação tão bem. Talvez alguém possa pensar em uma palavra melhor do que "até".

Eu só quero registrar meu voto na sugestão de Aaron G comefrom- o primeiro uso apropriado que eu vi da declaração COMEFROM da INTERCAL . A idéia é que é o oposto do GOTO (saltando para longe da instrução GOTO), pois faz com que algum lugar no seu código vá para a instrução COMEFROM.

Como estamos lidando com Task<T>s, que tal usar startcomo palavra-chave que precede a declaração, como em:

start var document = FetchAsync(urls[i]);

Vale ressaltar que o F # também usa a asyncpalavra - chave em seus fluxos de trabalho assíncronos, o que é praticamente a mesma coisa que a nova funcionalidade assíncrona no C # 5. Portanto, eu manteria o mesmo

Para a awaitpalavra - chave em F #, eles apenas usam em let!vez de let. O C # não tem a mesma sintaxe de atribuição, portanto, eles precisam de algo no lado direito do =sinal. Como Benjol disse, funciona da mesma yieldmaneira que deveria ser quase uma variante disso.

yield async FetchAsync(..)

Isso vai perfeitamente com o async modificador que você precisa aplicar no método que está chamando. E também a semântica da corrente, yield returnou seja, você retorna e produz execução para o código enumerador enquanto, nesse caso, está produzindo sua execução para o método assíncrono.

Imagine se, no futuro, houver outros usos para yield , poderíamos adicionar um em yield xque x é o novo recurso brilhante, em vez de termos todas essas palavras-chave diferentes para fazer basicamente a mesma coisa, render execução.

Sinceramente, não entendo bem o argumento 'não rendendo execução'. Afinal, o objetivo de chamar outro método já não é 'render execução' para esse método? Independentemente de ser assíncrono ou não? Estou faltando alguma coisa aqui?

E bom para você se o async retorno de forma síncrona, mas com a palavra-chave lá, significar que há uma chance provável de que o método seja executado de forma assíncrona e que você esteja produzindo execução para outro método. Seu método deve levar isso em consideração, independentemente de o método realmente fazer chamadas assíncronas ou não.

Na IMO, acho que os vários casos "não ceder" são um detalhe de implementação. Eu prefiro garantir a consistência no idioma (ou seja, reutilizar yield).

Que tal complete, como em "Quero que a tarefa seja concluída"?

Task<byte[]> downloadTask = DownloadFileAsync(url);
byte[] data = complete downloadTask;

task(para declaração do método) e async(dentro do corpo do método)