EP>>Как пример — эти аллокации вылезают по всему коду, <b><u>при простейших абстракциях</u></b> — просадка 16x на ровном месте.
I>Такой код в своём уме никто не пишет, кроме вчерашних плюсовиков, которые не знают как устроена память.
[...]
I>С такими проблемами как ты показал, не надо бороться против языка, наоборот, его надо интенсивно использовать.

EP>>define высокоуровневый. только тот что вшит в язык?

private async void handler(object sender, TaskArgs args)
{
    string result = await new Task(() => Download(args.Url), args.Cancellation);
    textBox.Text += result;
}

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

...Select(x => x.ToString())

void handler(object& sender, TaskArgs& args)
{
    coroutines_list.emplace_back([&](Coroutine::caller_type& c){
        HttpClient client;
        auto response=async(launch::async, [&](){return client.GetSync(args.Url, args.Cancellation);});
        while(response.wait_for(chrono::seconds(0))!=future_status::ready) c();
        response.get().EnsureSuccessStatusCode();
        auto result=async(launch::async, [&](){return response.get.Content.ReadAsStringSync();});
        while(result.wait_for(chrono::seconds(0))!=future_status::ready) c();
        textBox.Text+=result.get();
    });
}

for(auto& c: coroutines_list) c();
coroutines_list.remove_if([](const Coroutine& c){return !c;});

void Window::Handler(object& sender, TaskArgs& args)
{
    thread([&](){
        HttpClient client;
        auto response=client.GetSync(args.Url, args.Cancellation);
        response.EnsureSuccessStatusCode();
        PostMessage(NEW_DATA, response.Content.ReadAsStringSync());//PostMessage - функция-член Window
    }).detach();
}
void Window::OnNewData(const Data& data)
{
    textBox.Text+=data.get<string>();
}

Внутренняя ошибка сервера

URL: /Forum/Main.aspx

Transaction (Process ID 74) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.

support@rsdn.ru

EP>private async void handler(object sender, TaskArgs args)
EP>{
EP>    string result = await new Task(() => Download(args.Url), args.Cancellation);
EP>    textBox.Text += result;
EP>}
EP>

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

EP>

void foo(... fd - parameters structure ... )
{


    boost::asio::ip::tcp::resolver::query q("222.111.222.111", "1080");
    boost::asio::ip::tcp::resolver::iterator it;
    boost::system::error_code ec = resolve_resume(*fd.io, q, it);


    boost::asio::ip::tcp::socket sock(*fd.io);
    ec = connect_resume(sock, it);

    size_t bytes_transfered;
    boost::asio::streambuf socks_request;

    /// ... build socks_request ...

    ec = write_resume(sock, socks_request, bytes_transfered);

    boost::asio::streambuf socks_response;
    ec = read_resume(sock, socks_response, boost::asio::transfer_at_least(1), bytes_transfered);


    boost::asio::streambuf request;

    /// ... build request ...

    ec = write_resume(sock, request, bytes_transfered);

    boost::asio::streambuf response;
    while (!ec)
    {
        ec = read_resume(sock, response, boost::asio::transfer_at_least(1), bytes_transfered);
    }

    co_exit();
}

struct connect_handler_resume
{
private:
    coroutine_t owner_fiber;
    boost::system::error_code *ec;
public:
    connect_handler_resume(coroutine_t owner_fiber,
                            boost::system::error_code *ec)
                            : owner_fiber(owner_fiber), ec(ec)
    {

    }

    void operator()(const boost::system::error_code& ec);
};


// этот код вызовется по завершении операции
void connect_handler_resume::operator()(const boost::system::error_code& ec)
{
    *this->ec = ec;
    co_call(owner_fiber); // здесь возврат в корутину
}

boost::system::error_code connect_resume(boost::asio::ip::tcp::socket &sock,
                                        boost::asio::ip::tcp::resolver::iterator it)
{
    boost::system::error_code ec;

    connect_handler_resume handler(co_current(), &ec);
    sock.async_connect(*it, handler);

    /**----------*/
    co_resume(); //здесь уходим из корутины и сюда же нас вернёт вызов co_call(owner_fiber);
    /**----------*/

    return ec;
}