Question

I have a class (NamedPipeManager) which has a thread (PipeThread) that waits for a NamedPipe connection using (ConnectNamedPipe) and then reads (ReadFile) – these are blocking calls (not-overlapped) – however there comes a point when I want to unblock them – for example when the calling class tries to stop the NamedPipeManager…

How can I interupt it? Using Thread.abort? Thread.interrupt? Is there a proper way to handle this?
Refer to the code below which illustrates my current situation

main()
{
    NamedPipeManager np = new NamedPipeManager();
        ... do stuff ...
    ... do stuff ...
    np.Stop();      // at this point I want to stop waiting on a connection
}


class NamedPipeManager
{
private Thread PipeThread;

public NamedPipeManager
{
    PipeThread = new Thread(new ThreadStart(ManagePipes));
    PipeThread.IsBackground = true;
    PipeThread.Name = "NamedPipe Manager";
    PipeThread.Start();
}

private void ManagePipes()
{
    handle = CreateNamedPipe(..., PIPE_WAIT, ...);
    ConnectNamedPipe(handle, null);     // this is the BLOCKING call waiting for client connection

    ReadFile(....);             // this is the BLOCKING call to readfile after a connection has been established
    }


public void Stop()
{
    /// This is where I need to do my magic
    /// But somehow I need to stop PipeThread
    PipeThread.abort();     //?? my gut tells me this is bad
}
};

So, in function Stop() – how would I gracefully unblock the call to ConnectNamedPipe(…) or ReadFile(…)?

Any help would be appreciated.
Thanks,

Answer 1

Starting with Windows Vista, there is a CancelSynchronousIO operation available for threads. I don’t think there is a C# wrapper for it, so you would need to use PInvoke to call it.

Before Vista, there isn’t really a way to perform such an operation gracefully. I would advise against using thread cancellation (which might work, but doesn’t qualify as graceful). Your best approach is to use overlapped IO.