在 ReadFile() 之上创建异步“ReadFileMany()”

Question

我正在尝试创建一个函数，ReadFileMany，它模仿 ReadFile 的接口，它给出了一个 list 的（偏移量，长度）对来读取，并且异步读取文件的所有部分。

我在ReadFileMany 内部执行此操作，使用RegisterWaitForSingleObject 指示线程池线程等待I/O 完成，以便它可以再次调用ReadFile 来读取文件的下一部分，等等

我遇到的问题是我似乎无法模仿 ReadFile 的某种行为。
具体来说，文件句柄本身可以像事件一样使用，不需要事件句柄：

OVERLAPPED ov = {0};
DWORD nw;
if (ReadFile(hFile, buf, buf_size, &nw, &ov))
{
    if (WaitForSingleObject(hFile, INFINITE) == WAIT_OBJECT_0)
    {
        ...
    }
}

当然，如果用户在等待一个文件句柄，他可能会收到一个中间读取已完成的通知，而不是最终读取。

所以，在ReadFileMany 中，我别无选择，只能将hEvent 参数传递给ReadFile，除了最后一部分。

问题是，有没有办法让用户在读取所有部分后仍然等待文件句柄发出信号？

起初答案似乎很明显：在读取 last 部分时避免传递事件句柄！
如果读取成功，则效果很好，但如果出现错误，则效果不佳。如果 ReadFile 在上次读取时突然返回错误，我将需要手动将文件句柄设置为信号状态，以便让读者从对 @987654334 的潜在调用中醒来@。

但似乎没有办法在不执行实际 I/O 的情况下将 文件句柄 设置为信号状态...所以这就是我卡住的地方：我有什么办法可以编写这个函数，使其在外部表现得像ReadFile，还是不可能正确地做到这一点？

Answer 1

假设您正在尝试读取单个文件的多个部分，我将简单地分配一个 OVERLAPPED 结构数组，一个用于文件的每个请求部分，一次启动所有 ReadFile() 调用，然后使用WaitForMultipleObjects() 等待所有 I/O 完成，例如：

struct sReadInfo
{
    OVERLAPPED ov;
    LPVOID pBuffer;
    DWORD dwNumBytes;
    DWORD dwNumBytesRead;
    bool bPending;

    sReadInfo()
    {
        memset(&ov, 0, sizeof(OVERLAPPED));
        pBuffer = NULL;
        dwNumBytes = 0;
        dwNumBytesRead = 0;
        bPending = false;

        ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (!ov.hEvent) throw std::exception();
    }

    ~sReadInfo()
    {
        CloseHandle(hEvent);
    }
};

.

bool error = false;

try
{
    std::vector<sReadInfo> ri(numSections);

    std::vector<HANDLE> h;
    h.reserve(numSections);

    for(int i = 0; i < numSections; ++i)
    {
        ULARGE_INTEGER ul;
        ul.QuadPart = ...; // desired file offset to read from

        sReadInfo *r = &ri[i];

        r->ov.Offset = ul.LowPart;
        r->ov.OffsetHigh = ul.HighPart;

        r->pBuffer = ...; // desired buffer to read into
        r->dwNumBytes = ...; // desired number of bytes to read

        if (!ReadFile(hFile, r->pBuffer, r->dwNumBytes, &r->dwNumBytesRead, &r->ov))
        {
            if (GetLastError() != ERROR_IO_PENDING)
                throw std::exception();

            r->bPending = true;
            h.push_back(r->ov.hEvent);
        }
    }

    if (!h.empty())
    {
        if (WaitForMultipleObjects(h.size(), &h[0], TRUE, INFINITE) != WAIT_OBJECT_0)
            throw std::exception();
    }

    for (int i = 0; i < numSections; ++i)
    {
        sReadInfo *r = &ri[i];

        if (r->bPending)
            GetOverlappedResult(hFile, &r->ov, &r->dwNumBytesRead, FALSE);

        // ...
    }
}
catch (const std::exception &)
{
    CancelIo(hFile);
    return false;
}

return true;