EP>>>>Ты вроде как толком не ответил, что не так с продолжениями в C++

G>class A
G>{
G>    int x;
G>}
G>Func<int> GetFunc()
G>{
G>    var closure = new A { x = 0 };
G>    return () => closure.x++;
G>}
G>

#include <functional>
using namespace std;

struct A
{
    int x;
};

function<int()> GetFunc()
{
    A c = {0};
    return [=]() mutable { return c.x++; };
}

int main()
{
    auto x = GetFunc();
    return x()+x()+x()-3;
}

EP>>>>Нет, каждый элемент нужно обрабатывать много раз. Причём такие элементы будут хранится не только в массиве — это общий пример на простой абстракции в виде группировки элементов

EP>>>>А я и не говорил что оптимизация это самоцель — действительно, если тебе нужно обрабатывать 90 байтиков в секунду, то можешь хоть visual basic взять

EP>>Где я это доказывал?

EP>>Там где нужна производительность — у C++ пока практически нет конкурентов, там где не нужна — можно использовать либо C++, либо что-то другое — зависит от конкретной задачи

EP>>"Чтобы ты лучше понял", C++ код приведённый выше именно это и делает, ну разве кроме EnsureSuccessStatusCode и второго await'а которых не было в исходном запросе

template<typename F, typename T>
Task<result_of<F()>::type> background(F f, T t)
{
    return Task<result_of<F()>::type>(f, t);
}

G>Потому что время работы такого приложения начинает зависеть от скорости диска Это делает неверным большинство твоих рассуждений.

function<int()> GetFunc()
{
    auto c = make_shared<A>(A{0});
    return [=]{ return c->x++; };
}

EP>>>>Там где нужна производительность — у C++ пока практически нет конкурентов, там где не нужна — можно использовать либо C++, либо что-то другое — зависит от конкретной задачи

void test1(async)
{ 
    state_machine(test1)
    {
         cout << 1 << endl;
         await do_async( print("a1") );
         cout << 2 << endl;
         await do_async( print("a2") );
         cout << 3 << endl;
    }
}
 
void test2(async)
{ 
    state_machine(test2)
    {
         cout << "x" << endl;
         await do_async( print("b1") );
         cout << "y" << endl;
         await do_async( print("b2") );
         cout << "z" << endl;
    }
}
 
int main()
{
    test1();
    test2();
    while(!async_q.empty())
    {
        cout << "async loop" << endl;
        async_q.front()();
        async_q.pop();
    }
}

1
x
async loop
a1
async loop
2
async loop
b1
async loop
y
async loop
a2
async loop
3
async loop
b2
async loop
z

G>Код покажи

void handler(Object sender, TaskArgs args)
{
    StartNew( () => download(args.url), args.cancellation, on_workpool).then
    (
        result => textBox.Text += result,
        on_gui_thread
    );
}

_>P.S. Кстати, после того как мы выяснили что асинхронный код не просто можно записывать на C++, но он ещё и даже короче, было бы очень интересно ещё и сравнить быстродействие...

if(code_of_user_progra_that_made_request == C_PLUS_PLUS)
   FastestProcessing();
else
   SlowProcessing();

if (connection->client_is_managed())
   connection->set_slow_mode();

EP>>

EP>>А что это такое белое и пушистое прилетело в виде System.ObjectDisposedException?

I>>>Отсюда ясно, что __обязательность__ какого то выбора это совсем не то же самое, что и свобода выбора. Вот если бы можно было передавать лямбды как попало, а вот тюнить надо было только для перформанса-расхода памяти, тогда другое дело.

EP>>void handler(Object &sender, TaskArgs &args)
EP>>{
EP>>    background(bind(download, args.url), args.cancellation),
EP>>    textBox.Text += _1;
EP>>}
EP>>

EP>>

background([=]{ return download(args.url); }, args.cancellation)

    background(bind(download, args.url), args.cancellation),
    textBox.Text += _1,
    await([=]{ return download(args.url + "foo"); }),
    textBoxBar.Text += _1;