I>>>А где же асинхронщина ? Предположим, это единственный код в приложении, а чтение из стрима занимает 5 минут. Итого — асинхронщина, в твоем понимании, это зависание UI на 5 минут.

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

M>>    textBox.Text += result;   // когда сюда придет управление
M>>}
M>>

The await operator is applied to a task in an asynchronous method to suspend the execution of the method until the awaited task completes. The task represents ongoing work.

I>Качественно ты его слил

I> Покажи этот код, а то вот EP не может

Например, в examples к Boost.Coroutine есть пример простого сервера, который асинхронно считывает сообщения из tcp порта и выводит их на экран — причём всё это происходит в одном потоке. Цикл считывания выглядит точно также как и обыкновенный синхронный код:

#include <boost/range/algorithm_ext.hpp>
#include <boost/range/algorithm.hpp>

#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/stream.hpp>

#include <boost/coroutine/all.hpp>

#include <functional>
#include <algorithm>
#include <iostream>
#include <cstddef>
#include <utility>
#include <string>
#include <vector>
#include <deque>

using namespace boost;
using namespace std;
using namespace placeholders;

typedef coroutines::coroutine<void()> Coro;
typedef deque<char> Buffer;

struct DataSource
{
    typedef char        char_type;
    typedef iostreams::source_tag category;

    Coro::caller_type &ca;
    Buffer &buffer;

    std::streamsize read(char* out, streamsize n)
    {
        if(buffer.empty())
        {
            ca();
            if(buffer.empty()) return -1;
        }
        auto actual_n = min(n, streamsize(buffer.size()));
        auto first = buffer.begin();
        auto last = first + actual_n;
        copy(first, last, out);
        buffer.erase(first, last);
        return actual_n;
    }
};
typedef iostreams::stream<DataSource> TcpStream;

void foo(TcpStream &client_stream)
{
    string msg;
    do
    {
        getline(client_stream, msg);
        cout << "stream address: " << &client_stream << "|\t";
        cout << msg << endl;
    } while(msg != "exit");
}

void coroutine_start(Buffer *buffer,Coro::caller_type &ca)
{
    DataSource source{ca, *buffer};
    TcpStream client_stream(source);
    foo(client_stream);
}

int main()
{
    vector<Coro> fibers;
    vector<Buffer> buffers(4);
    for(auto &buffer : buffers)
        fibers.emplace_back(bind(coroutine_start, &buffer, _1));

    struct StreamData
    {
        size_t receiver;
        string msg;
    } const stream_datas[] =
    {
        {0, "Hello"},
        {1, "World"},
        {2, "Stackfull"},
        {3, "Coroutines"},
        {2, "Rulez!"},
        {1, "Hasta la vista"},
        {0, "Baby"}
    };

    for(auto &sd : stream_datas)
    {
        auto &buffer = buffers[sd.receiver];
        push_back(buffer, sd.msg);
        buffer.push_back('\n');
        fibers[sd.receiver]();
    }

    for(auto &buffer : buffers)
        push_back(buffer, "exit\n");
    for(auto &c : fibers)
       c();
}

stream address: 0x7fc742afdc10| Hello
stream address: 0x7fc742aebc10| World
stream address: 0x7fc742ad9c10| Stackfull
stream address: 0x7fc742ac7c10| Coroutines
stream address: 0x7fc742ad9c10| Rulez!
stream address: 0x7fc742aebc10| Hasta la vista
stream address: 0x7fc742afdc10| Baby
stream address: 0x7fc742afdc10| exit
stream address: 0x7fc742aebc10| exit
stream address: 0x7fc742ad9c10| exit
stream address: 0x7fc742ac7c10| exit

I>Странно, но ты снова привел __синхронный__ код Если короутина прыгает между стеками, еще не значит, что код автоматически становится асинхронным.

Asynchronous I/O, in computer science, is a form of input/output processing that permits other processing to continue before the transmission has finished.

for(auto &buffer : buffers)
        fibers.emplace_back(bind(coroutine_start, &buffer, _1));

I>Ну и так же ты показал, что в предыдущем примере у тебя, мягко говоря, отсутствовало 99% решения

void foo(std::istream &client_stream)
{
    string msg;
    do
    {
        getline(client_stream, msg);
        cout << msg << endl; 
    } while(msg != "exit");
}