int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpCmdLine, int nCmdShow)
{
    AttachConsole();
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0)>0){
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

void SomeMessageHandler()
{
    wstring buf;
    getline(wcin, buf);
    wcout<<L"Эхо: "<<buf;
}

AsyncPool async_pool;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpCmdLine, int nCmdShow)
{
    AttachConsole();
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0)>0){
        async_pool.RunAll();
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

void SomeMessageHandler()
{
    async_pool.Add([=](AsyncPool::This& this_async){//эти две строки можно для красоты запрятать
        wistream async_wcin(new АsyncBuf(this_async, wcin.rdbuf()));//в макрос :D
        wstring buf;
        getline(async_wcin, buf);
        wcout<<L"Эхо: "<<buf;
    });
}

class AsyncPool{
    using Coro=boost::coroutines::coroutine<void()>;
    list<Coro> coro_list;
public:
    using This=Coro::caller_type;
    template<typename L> void Add(L l) {coro_list.emplace_back(l);}
    void RunAll()
    {
        for(auto& c: coro_list) c();
        coro_list.remove_if([](const Coro& c) {return !c;});
    }
}

class АsyncBuf: public wstreambuf{
AsyncPool::This& this_async;
wstreambuf* sync_buf;
public:
    АsyncBuf(AsyncPool::This& c, wstreambuf* sb): this_async(c), sync_buf(sb){}
    wchar_t getc()//псевдокод, т.к. я не помню реальный api у std::streambuf
    {
        while(!sync_buf->is_avail()) this_async();
        return sync_buf->getc();
    }
};

I>Смешно — короутины есть в современных OS с незапамятных времен и как то это никак не сказалось на асинхронщине

AsyncPool async_pool;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpCmdLine, int nCmdShow)
{
    AttachConsole();
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0)>0){
        async_pool.RunAll();
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

void SomeMessageHandler()
{
    async_pool.Add([=](AsyncPool::This& this_async){//эти две строки можно для красоты
        auto r=await_async(this_async, [&](){//запрятать в макрос :D
            wstring buf;
            getline(wcin, buf);
            return buf;
        });
        wcout<<L"Эхо: "<<r;
    });
}

case WM_USER: // все прост, никаких фокусов
  textBox.text += await handler();
  break;

string async handler()
{
  var http = new Http("some url");
  var result = await Task.FromBeginEnd(asyncCallback)=>http.BeginRead(asyncCallback), (asyncResult)=>http.EndRead(asyncResult) );

  return string;
}

I>case WM_USER: // все прост, никаких фокусов
I>  textBox.text += await handler();
I>  break;
I>

#include <boost/coroutine/all.hpp>
#include <functional>
#include <algorithm>
#include <cstring>
#include <memory>
using namespace std;

#include <windows.h>

function<void()> on_minization;

template<typename F>
void async_something(F f)
{
    on_minization = f;
}

void task()
{
    MessageBox(0, TEXT("on max"), TEXT(""), MB_OK);
    async_something([]
    {
        MessageBox(0, TEXT("on min"), TEXT(""), MB_OK);
    });
}

LRESULT CALLBACK window_procedure(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_param)
{
    switch (msg)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        case WM_SIZE:
            switch(w_param)
            {
                case SIZE_MAXIMIZED:
                    task();
                    break;
                case SIZE_MINIMIZED:
                    if(on_minization) on_minization();
                    break;
            }
        default:
            return DefWindowProc(hwnd, msg, w_param, l_param);
    }
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
    WNDCLASS wincl = {};
    wincl.hInstance = hInstance;
    wincl.lpszClassName = TEXT("SFC");
    wincl.lpfnWndProc = window_procedure;
    RegisterClass(&wincl);

    auto hwnd = CreateWindow(wincl.lpszClassName, TEXT(""), WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, hInstance, 0);
    ShowWindow (hwnd, nCmdShow);

    MSG msg;
    while(GetMessage(&msg, 0, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
}

void SomeMessageHandler()
{
    thread([=](){
        wstring buf;
        getline(wcin, buf);
        PostMessage(buf);
    }.detach();
}

M>А правильное решение состоит в использовани отдельного потока для GUI.

thread([=](){
    PostMessage(Download(url));
}).detach();

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpCmdLine, int nCmdShow)
{
    AttachConsole();
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0)>0){
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

void task()
{
    MessageBox(0, TEXT("on max"), TEXT(""), MB_OK);
    async_something([]
    {
        MessageBox(0, TEXT("on min"), TEXT(""), MB_OK);
    });
}

thread([=](){PostMessage(download(url));}).detach();