async & await - encuesta de alternativas [cerrado]

Ahora que sabemos lo que está reservado para c # 5, aparentemente todavía hay una oportunidad para que podamos influir en la elección de las dos nuevas palabras clave para ' Asincronía ' que Anders Heijsberg anunció ayer en 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 tiene una explicación de la elección de las dos palabras clave actuales, y la forma en que han sido mal entendidas en los estudios de usabilidad. Los comentarios tienen varias otras proposiciones.

Por favor, una sugerencia por respuesta, se duplicarán los duplicados.

Dado que no tengo claro el significado / necesidad de async, realmente no puedo discutirlo, pero mi mejor sugerencia para reemplazar awaites:

yield while (mira! no hay nuevas palabras clave)

Tenga en cuenta que después de haber pensado en esto un poco más, me pregunto si reutilizar de whileesta manera es una buena idea; la tendencia natural sería esperar un booleano después.

(Piensa: encontrar buenas palabras clave es como encontrar buenos nombres de dominio :)

¿Qué tal no tener una palabra clave?

Me gustaría que el compilador se dé cuenta de que, la mayoría de las veces, cuando llamo a un método asincrónico, quiero el resultado.

Document doc = DownloadDocumentAsync();

Eso es. La razón por la que las personas están teniendo dificultades para pensar una palabra clave para esto es porque es como tener una palabra clave para "hacer lo que haría si las cosas fueran perfectamente normales". Esa debería ser la predeterminada, no requiere una palabra clave.

Actualizar

Originalmente sugerí que el compilador debería ser inteligente con la inferencia de tipos para descubrir qué hacer. Pensando más en esto, mantendría la implementación existente en el CTP tal como es, pero haré un par de adiciones triviales, para reducir los casos en los que necesitaría usar la awaitpalabra clave explícitamente.

Nos inventamos un atributo: [AutoAwait]. Esto solo se puede aplicar a los métodos. Una forma de aplicar esto a su método es marcarlo async. Pero también puede hacerlo a mano, por ejemplo:

[AutoAwait]
public Task<Document> DownloadDocumentAsync()

Luego, dentro de cualquier asyncmétodo, el compilador asumirá que desea esperar una llamada DownloadDocumentAsync, por lo que no necesita especificarlo. Cualquier llamada a ese método lo esperará automáticamente.

Document doc = DownloadDocumentAsync();

Ahora, si desea "ser inteligente" y obtener el Task<Document>, utilice un operador start, que solo puede aparecer antes de una llamada al método:

Task<Document> task = start DownloadDocumentAsync();

Aseado, creo. Ahora, una llamada de método simple significa lo que generalmente significa: esperar a que se complete el método. E startindica algo diferente: no esperes.

Para el código que aparece fuera de un asyncmétodo, la única forma en que puede llamar a un [AutoAwait]método es mediante el prefijo start. Esto lo obliga a escribir código que tenga el mismo significado independientemente de si aparece en un asyncmétodo o no.

¡Entonces empiezo a ponerme codicioso! :)

En primer lugar, quiero asyncaplicar a los métodos de interfaz:

interface IThing
{
    async int GetCount();
} 

Básicamente significa que el método de implementación debe regresar Task<int>o algo compatible await, y las personas que llaman al método obtendrán un [AutoAwait]comportamiento.

Además, cuando implemente el método anterior, quiero poder escribir:

async int GetCount()

Así que no tengo que mencionar Task<int>como tipo de retorno.

Además, quiero asyncaplicar a los tipos de delegados (que, después de todo, son como interfaces con un método). Entonces:

public async delegate TResult AsyncFunc<TResult>();

Un asyncdelegado tiene, lo has adivinado, [AutoAwait]comportamiento. Desde un asyncmétodo puede llamarlo y se editará automáticamente await(a menos que elija simplemente start). Y entonces si dices:

AsyncFunc<Document> getDoc = DownloadDocumentAsync;

Eso solo funciona. No es una llamada al método. Aún no se ha iniciado ninguna tarea, y async delegateno es una tarea. Es una fábrica para hacer tareas. Puedes decir:

Document doc = getDoc();

Y eso comenzará una tarea y esperará a que termine y le dará el resultado. O puedes decir:

Task<Document> t = start getDoc();

Entonces, un lugar en este lugar donde se filtra la "plomería" es que si desea hacer un delegado a un asyncmétodo, debe saber usar un async delegatetipo. Entonces, en lugar de Funcusted debe decir AsyncFunc, y así sucesivamente. Aunque algún día ese tipo de cosas podría solucionarse mediante una mejor inferencia de tipos.

Otra pregunta es qué debería suceder si dice comenzar con un método ordinario (no asíncrono). Obviamente, un error de compilación sería la opción segura. Pero hay otras posibilidades.

hearken unto AsyncFetch(…)

(si no lo entiendes, lee la entrada del blog de Eric . Al menos es mejor que for sooth Romeo wherefore art thou AsyncFetch(…))

Creo que asyncestá bien, pero tal vez sea porque lo asocio con las páginas asincrónicas de ASP.NET, la misma idea.

Para la awaitpalabra clave prefiero continue aftero resume after.

No me gusta yieldni ninguna de sus variantes, porque la semántica es tal que el método nunca puede generar ejecución; Depende del estado de la tarea.

También agregué comentarios en el blog de Eric, no veo ningún problema con el uso de la misma palabra clave async

var data = async DownloadFileAsync(url);

Solo estoy expresando que quiero descargar el archivo de forma asincrónica. Aquí hay un poco de redundancia, "async" aparece dos veces, porque también está en el nombre del método. El compilador podría ser más inteligente y detectar la convención de que los métodos que terminan en "Asíncrono" son métodos asíncronos de hecho, y agregarlo para nosotros en el código compilado. Entonces, en vez de eso, solo querrás llamar

var data = async DownloadFile(url);

en lugar de llamar al síncrono

var data = DownloadFile(url);

Diablos, también deberíamos poder definirlos de la misma manera, ya que la palabra clave asincrónica está allí en nuestra declaración, ¿por qué debemos agregar manualmente "Async" a cada nombre de método? El compilador puede hacerlo por nosotros.

async = task : está modificando una función para devolver una tarea, entonces, ¿por qué no usar la palabra clave "task"?

await = terminar - No necesariamente tenemos que esperar, pero la tarea tiene que "terminar" antes de usar el resultado.

Me gusta yield until. yield while, ya sugerido, es excelente y no introduce palabras clave nuevas, pero creo que "hasta" captura el comportamiento un poco mejor.

Creo que yield <something>es una gran idea, porque el rendimiento ya captura la idea de hacer que el resto del método sea una continuación tan bien. Quizás alguien pueda pensar en una palabra mejor que "hasta".

Solo quiero registrar mi voto para la sugerencia de Aaron G del comefromprimer uso apropiado que he visto de la declaración COMEFROM de INTERCAL . La idea es que es algo opuesto a GOTO (saltando de la declaración GOTO) en que hace que algún lugar en su código salte a la declaración COMEFROM.

Como estamos tratando con Task<T>s, ¿qué tal si usamos startcomo palabra clave antes de la declaración, como en:

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

Vale la pena señalar que F # también usa la asyncpalabra clave en sus flujos de trabajo asíncronos, que es casi exactamente lo mismo que la nueva funcionalidad asíncrona en C # 5. Por lo tanto, lo mantendría igual

Para la awaitpalabra clave en F #, solo usan en let!lugar de let. C # no tiene la misma sintaxis de asignación, por lo que necesitan algo en el lado derecho del =signo. Como dijo Benjol, funciona igual yieldque casi debería ser una variante de eso.

yield async FetchAsync(..)

Esto va perfectamente con el asyncmodificador que necesita para poner el método que está invocando. Y también la semántica de la corriente yield return, es decir, devuelve y produce la ejecución del código de enumeración, mientras que en este caso está cediendo su ejecución al método asincrónico.

Imagínese si en el futuro habrá otros usos para yield, podríamos agregar un yield xdonde x es la nueva característica brillante en lugar de tener todas estas palabras clave diferentes para hacer principalmente la misma cosa, rendimiento de ejecución.

Francamente, no entiendo muy bien el argumento de 'no ceder ejecución'. Después de todo, ¿el punto de llamar a otro método ya no es 'ceder la ejecución' de ese método? ¿Independientemente de si es asíncrono o no? ¿Me estoy perdiendo algo aquí?

Y es bueno para usted si el asyncretorno es sincrónico, pero tener la palabra clave allí debería significar que existe una posibilidad probable de que el método se ejecute de forma asincrónica y que esté ejecutando la ejecución a otro método. Su método debe tener en cuenta eso independientemente de si el método realmente hace llamadas asincrónicas o no.

En mi opinión, los diversos casos de 'no rendir' son un detalle de implementación. Prefiero garantizar la coherencia en el lenguaje (es decir, reutilizar yield).

¿Qué completetal, como en "Quiero completar la tarea"?

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

task(para la declaración del método) y async(dentro del cuerpo del método)