async & wait - опитування на альтернативи [закрито]

Тепер, коли ми знаємо, що є у продажу для №5, нам, мабуть, ще є відкриття для впливу на вибір двох нових ключових слів для « Асинхронії », які вчора оголосив Андерс Хейсберг на 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);
    }
}

Ерік Ліпперт має пояснення щодо вибору двох останніх ключових слів і способу їх неправильного розуміння в дослідженнях зручності. У коментарях є кілька інших пропозицій.

Будь ласка - одна пропозиція на відповідь, дублікати будуть нульовими.

Зважаючи на те, що мені не зрозуміло сенс / необхідність async, я не можу з цим дійсно сперечатися, але найкраща моя пропозиція щодо заміни await:

yield while (дивіться! нових ключових слів немає)

Зауваживши , подумавши про це трохи більше, мені цікаво, чи повторне використання whileцього способу є хорошою ідеєю - природною тенденцією було б сподіватися на булеве згодом.

(Думає: знайти хороші ключові слова - це як знайти хороші доменні імена :)

Як щодо того, щоб не було ключового слова?

Я хотів би, щоб компілятор усвідомлював, що більшість часу, коли я викликаю асинхронний метод, я хочу, щоб результат його був.

Document doc = DownloadDocumentAsync();

Це воно. Причина, чому люди важко придумують ключове слово для цієї речі, це тому, що це як ключове слово для "робити те, що ти робив би, якби справи були абсолютно нормальними". Це повинно бути за замовчуванням, не вимагати ключового слова.

Оновлення

Спочатку я запропонував компілятору отримати розумний висновок про тип, щоб зрозуміти, що робити. Думаючи далі про це, я б зберег існуючу реалізацію в CTP такою, якою вона є, але внести до неї кілька дрібницьких доповнень, щоб зменшити випадки, коли вам потрібно буде awaitчітко використовувати ключове слово.

Ми винаходимо атрибут: [AutoAwait]. Це можна застосувати лише до методів. Один із способів застосувати це до вашого методу - позначити його async. Але ви також можете це зробити вручну, наприклад:

[AutoAwait]
public Task<Document> DownloadDocumentAsync()

Тоді всередині будь-якого asyncметоду компілятор припустить, що ви хочете чекати на виклик DownloadDocumentAsync, тому не потрібно його вказувати. Будь-який дзвінок до цього методу автоматично його чекає.

Document doc = DownloadDocumentAsync();

Тепер, якщо ви хочете "стати розумним" і отримати його Task<Document>, ви використовуєте оператор start, який може з'явитися лише перед викликом методу:

Task<Document> task = start DownloadDocumentAsync();

Охайний, я думаю. Тепер звичайний виклик методу означає те, що він зазвичай означає: чекайте завершення методу. І startвказує на щось інше: не чекай.

Для коду, який з’являється поза asyncметодом, єдиний спосіб, яким ви можете викликати [AutoAwait]метод, - це префіксація start. Це змушує вас писати код, який має однакове значення незалежно від того, відображається він у asyncметоді чи ні.

Тоді я починаю жадібний! :)

По-перше, я хочу asyncзастосувати методи інтерфейсу:

interface IThing
{
    async int GetCount();
} 

Це в основному означає, що метод реалізації повинен повернутися Task<int>або щось сумісне з await, і абоненти до методу отримають [AutoAwait]поведінку.

Також коли я реалізую вищевказаний метод, я хочу мати можливість писати:

async int GetCount()

Тому я не повинен згадувати Task<int>як тип повернення.

Також я хочу asyncзвернутися до типів делегатів (які, зрештою, схожі на інтерфейси одного методу). Так:

public async delegate TResult AsyncFunc<TResult>();

asyncДелегат має - ви вже здогадалися - [AutoAwait]поведінка. З asyncметоду ви можете викликати його, і він буде автоматично awaitвідредагований (якщо ви не вирішите його просто start). Так що, якщо ви кажете:

AsyncFunc<Document> getDoc = DownloadDocumentAsync;

Це просто працює. Це не виклик методу. Жодне завдання ще не розпочато - async delegateце не завдання. Це фабрика для виконання завдань. Ви можете сказати:

Document doc = getDoc();

І це почне завдання і чекатиме його закінчення і дасть результат. Або ви можете сказати:

Task<Document> t = start getDoc();

Тож одне місце в цьому місці, де "сантехніка" протікає, це те, що якщо ви хочете зробити делегат asyncметоду, ви повинні знати async delegateтип. Тож замість Funcвас треба сказати AsyncFuncтощо. Хоча одного дня такі речі можуть бути виправлені за допомогою поліпшеного виводу типу.

Інше питання - що має статися, якщо ви скажете почати із звичайного (несинхронного) методу. Очевидно, що помилка компіляції була б безпечним варіантом. Але є й інші можливості.

hearken unto AsyncFetch(…)

(якщо ви цього не отримаєте, прочитайте запис у блозі Еріка . Принаймні, це краще, ніж for sooth Romeo wherefore art thou AsyncFetch(…))

Я думаю, що asyncце добре, але, можливо, це тому, що я асоціюю його зі сторінками асинхронізації ASP.NET - та сама ідея.

Для awaitключового слова я віддаю перевагу continue afterабо resume after.

Мені не подобається yieldчи будь-який його варіант, тому що семантика така, що метод ніколи насправді не може виконати; це залежить від стану завдання.

Я також додав коментарі до блогу Еріка, я не бачу проблем із використанням одного і того ж ключового слова async

var data = async DownloadFileAsync(url);

Я просто висловлюю, що хочу завантажити файл асинхронно. Тут є трохи надмірності, "async" з'являється двічі, тому що це також у назві методу. Компілятор міг би бути надзвичайно розумним і виявити умовність, що методи, що закінчуються на "Асинхроні", є методами асинхронності без фактів, і додамо це для нас у компільований код. Тож замість цього ви можете просто зателефонувати

var data = async DownloadFile(url);

на відміну від виклику синхронного

var data = DownloadFile(url);

Хек, ми також повинні мати можливість визначати їх так само, оскільки ключове слово async є в нашій декларації, чому ми повинні вручну додавати "Async" до кожного імені методу - компілятор може це зробити для нас.

async = task - це модифікація функції для повернення завдання, то чому б не використати ключове слово "task"?

очікувати = закінчити - нам не обов’язково чекати, але завдання потрібно «закінчити» перед тим, як використовувати результат.

Мені подобається yield until. yield while, вже запропоновано, це чудово і не вводить нових ключових слів, але я думаю, що "до" захоплює поведінку трохи краще.

Я думаю yield <something>, що це відмінна ідея, оскільки вихід вже захоплює ідею зробити так, щоб решта методу була такою вдалою. Можливо, хтось може придумати краще слово, ніж «поки».

Я просто хочу зареєструвати свій голос за пропозицію Аарона G comefrom- перше відповідне використання, яке я бачив у заяві ІНТЕРКАЛ COMEFROM . Ідея полягає в тому, що це щось протилежне GOTO (відскакує від заяви GOTO), оскільки воно робить деяке місце у вашому коді перейти до оператора COMEFROM.

Оскільки ми маємо справу з Task<T>s, як щодо використання startключового слова, що передує оператору, як у:

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

Варто відзначити, що F # також використовує asyncключове слово у своїх робочих процесах асинхронізації, що майже все те саме, що і новий функціонал async у C # 5. Тому я б утримував це однаково

Для awaitключового слова у F # вони просто використовують let!замість let. У C # немає однакового синтаксису призначення, тому їм потрібно щось праворуч від =знака. Як сказав Бенжол, він функціонує так само, як і yieldтак, майже це повинен бути варіант.

yield async FetchAsync(..)

Це ідеально відповідає asyncмодифікатору, який потрібно застосувати до методу, до якого ви посилаєтесь. А також семантичністю поточного yield return, тобто ви повертаєтесь і даєте виконання виконуваному коду, що перераховує, в цьому випадку ви віддаєте своє виконання асинхронному методу.

Уявіть собі, якщо в майбутньому будуть інші напрямки використання yield, ми могли б додати a, yield xде x - це блискуча нова функція, а не всі ці різні ключові слова для того, щоб виконувати здебільшого одне і те ж, прибутковість виконання.

Чесно кажучи, я не зовсім розумію аргумент "не приносять виконання". Зрештою, хіба не сенс викликати інший метод - це «принести виконання» цьому методу? Незалежно від того, асинхронний він чи ні? Я щось тут пропускаю?

І добре для вас, якщо asyncповертається синхронно, але маючи там ключове слово, повинно означати, що існує ймовірність, що метод запуститься асинхронно і що ви будете підходити до виконання іншого методу. Ваш метод повинен враховувати це незалежно від того, чи дійсно метод виконує асинхронні дзвінки чи ні.

ІМО. Я думаю, що різні "незадовільні" випадки є деталізацією реалізації. Я б краще поручився за послідовність мови (тобто повторне використання yield).

Як щодо того complete, як у "Я хочу, щоб завдання було виконане"?

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

task(для декларування методу) та async(в тілі методу)