SOCKET socket = WSASocket ( protocol, type, 0, NULL, 0, 0);

    sockaddr_in address = {0};
    address.sin_family = protocol;
    address.sin_port = htons (port);
    address.sin_addr.s_addr = INADDR_ANY;

    OnSelect (socket, FD_ACCEPT | FD_CLOSE);
    bind (socket, (sockaddr*) &address, sizeof (address));
    listen (socket, 5);

bool TcpServer::OnAccept (const Socket& socket, long flags)
{
    sockaddr_in address = {0};
    address.sin_family = m_protocol;
    address.sin_port = htons (m_port);
    address.sin_addr.s_addr = INADDR_ANY;

    int size = sizeof (address);

    if (m_map.size() >= WSA_MAXIMUM_WAIT_EVENTS - 1) return false;
    Socket client = WSAAccept (socket, (sockaddr*) &address, &size, NULL, 0);
    if (client == INVALID_SOCKET)
    {
        SocketDebug ("TcpServer::OnAccept (WSAAccept)");
        return false;
    }

    return OnSelect (client, flags);
}
bool TcpServer::OnSelect (const Socket& socket, long flags)
{
    WsaEvent event;
    if (WSAEventSelect (socket, event, flags) == SOCKET_ERROR)
    {
        SocketDebug ("TcpServer::OnAccept (WSAEventSelect)");
        return false;
    }

    m_map[event] = socket;
    update ();
    return true;
}

unsigned TcpServer::MainThread (void* arg)
{

    WSANETWORKEVENTS net_events = {0};
    while (!m_stopped)
    {
        DWORD index = WSAWaitForMultipleEvents ((DWORD)m_events.size(),
            &m_events[0], FALSE, WAIT_TIME, FALSE);

        if ((index == WSA_WAIT_FAILED) || (index == WSA_WAIT_TIMEOUT))
        {
            continue;
        }

        WsaEvent event = m_events [index - WSA_WAIT_EVENT_0];
        Socket& socket = m_map[event];

        if (WSAEnumNetworkEvents (socket, event, &net_events) == SOCKET_ERROR)
        {
            SocketDebug ("TcpServer::MainThread (WSAEnumNetworkEvents)");
            break;
        }

        event.reset();
        if (net_events.lNetworkEvents & FD_CONNECT)
        {
            if (net_events.iErrorCode[FD_CONNECT_BIT] != 0)
            {
                OnClose (event);
                continue;
            }
            OnConnect (socket);
            StreamDebug ("Connect...");
        }
        if (net_events.lNetworkEvents & FD_ACCEPT)
        {
            if (net_events.iErrorCode[FD_ACCEPT_BIT] != 0)
            {
                OnClose (event);
                continue;
            }
            OnAccept (socket, FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE);
            StreamDebug ("Accept...");
        }
        if (net_events.lNetworkEvents & FD_CLOSE)
        {
            OnClose (event);
            StreamDebug ("Disconnect...");
        }
        if (net_events.lNetworkEvents & FD_READ)
        {
            if (net_events.iErrorCode[FD_READ_BIT] != 0)
            {
                OnClose (event);
                continue;
            }
            OnReceive (socket);
            StreamDebug ("Receive...");
        }
        if (net_events.lNetworkEvents & FD_WRITE)
        {
            if (net_events.iErrorCode[FD_WRITE_BIT] != 0)
            {
                OnClose (event);
                continue;
            }
            OnSend (socket);
            StreamDebug ("Send...");
        }
    }

    return 0;
}

K>на счет WSACreateEvent не понял

K>сделат WSAEventSelect после bind и до listen — тоже самое

createsocket();  // серв сокет
bind(); // серв сокет
WSACreateEvent(); // для серв сокет. парная закрывающая - WSACloseEvent
WSAEventSelect(); //серв сокет
while (true) {
  //цикл бесконеч.
    //внимательно!!! для TCP указывать нада 
    //таймаут обязательно. в районе 10-15 мс. Иначе попа.
    Err = WSAWaitForMultipleEvents;  
    if(Err OK?) {
        Err2 = WSAEnumNetworkEvents();
        if(Err2 OK?) {
          //проверяем нужные поля
            //если есть FD_ACCEPT
            //то мы принимаем сокет и опять крутим цикл. 
            //т.е. мы создаем Event новый и добавляем в массив. 
            //для него тоже потребуется WSAWaitForMultipleEvents, как для сервер. сокета.
        } else {
          //проверим ошибку
        }
    } else {
      //проверить ошибку
    }
}

K>>на счет WSACreateEvent не понял

K>>сделат WSAEventSelect после bind и до listen — тоже самое

_>createsocket();  // серв сокет
_>bind(); // серв сокет
_>WSACreateEvent(); // для серв сокет. парная закрывающая - WSACloseEvent
_>WSAEventSelect(); //серв сокет
_>while (true) {
_>  //цикл бесконеч.
_>    //внимательно!!! для TCP указывать нада 
_>    //таймаут обязательно. в районе 10-15 мс. Иначе попа.
_>    Err = WSAWaitForMultipleEvents;  
_>    if(Err OK?) {
_>        Err2 = WSAEnumNetworkEvents();
_>        if(Err2 OK?) {
_>          //проверяем нужные поля
_>            //если есть FD_ACCEPT
_>            //то мы принимаем сокет и опять крутим цикл. 
_>            //т.е. мы создаем Event новый и добавляем в массив. 
_>            //для него тоже потребуется WSAWaitForMultipleEvents, как для сервер. сокета.
_>        } else {
_>          //проверим ошибку
_>        }
_>    } else {
_>      //проверить ошибку
_>    }
_>}
_>

    WsaEvent event; // <- в конструкторе вызывается WSACreateEvent
    if (WSAEventSelect (socket, event, flags) == SOCKET_ERROR)
    {
        return false;
    }

    m_map[event] = socket; // добавляем в std::map<WsaEvent, Socket>
    return true;

K>    WsaEvent event; // <- в конструкторе вызывается WSACreateEvent
K>    if (WSAEventSelect (socket, event, flags) == SOCKET_ERROR)
K>    {
K>        return false;
K>    }

K>    m_map[event] = socket; // добавляем в std::map<WsaEvent, Socket>
K>    return true;
K>

WSAEVENT event = WSAEventCreate();

WSAWaitForMultipleEvents(.., .., .., 15, ..);

K>>    WsaEvent event; // <- в конструкторе вызывается WSACreateEvent
K>>    if (WSAEventSelect (socket, event, flags) == SOCKET_ERROR)
K>>    {
K>>        return false;
K>>    }

K>>    m_map[event] = socket; // добавляем в std::map<WsaEvent, Socket>
K>>    return true; 
K>>

class WsaEvent {
private :
    boost::shared_ptr<void> m_event;

public :
    WsaEvent (WSAEVENT event = WSA_INVALID_EVENT);
    ~WsaEvent() {;}

    bool reset (void);
    operator WSAEVENT() const { return m_event.get(); }
};

WsaEvent::WsaEvent (WSAEVENT event) : m_event (event, WSACloseEvent)
{
    if (event != WSA_INVALID_EVENT) return;

    event = WSACreateEvent();
    if (event == WSA_INVALID_EVENT)
    {
        SocketDebug ("WsaEvent::WsaEvent (WSACreateEvent)");
        throw std::exception ("Ошибка создания события");
    }

    m_event.reset (event, WSACloseEvent);
}

bool WsaEvent::reset (void)
{
    if (!WSAResetEvent (*this))
    {
        SocketDebug ("WsaEvent::reset (WSAResetEvent)");
        return false;
    }
    return true;
}