How to detect cross thread access in .NET (enforce thread affinity)?

Question

I'm writing a special data structure that will be available in a .NET library and one of the features of this data structure is that is will be thread safe provided that only one thread writes data to it, and only one thread reads data from it (the reader thread and the writer thread can be different).

The question is how can I enforce that all Read operations are executed by the same thread?

My solution would be capture the System.Threading.Thread.ManagedThreadID and store it in a private member upon the first Read. Then, on subsequent reads to check the ManagedThreadID against the saved one and if they are different to throw an exception.

Is that enough, or is there a different more reliable mechanism for doing this.

Note: There is a requirement that this library be usable without a Windows.Forms context..

Answer 1

Could you not require the Read and Write methods take a thread or thread ID? Then you can just compare against the one that called it first, and if it doesn't match, throw an exception or return an error code, or ignore the request.

Otherwise, what you propose should work also. You need only compare the thread IDs.

Answer 2

Rather than compare thread ID's you should store the ambient Thread in your class during construction.

class SingleThreadedClass
{
    private Thread ownerThread;

    public SingleThreadedClass()
    {
        this.ownerThread = Thread.CurrentThread;
    }

    public void Read(...)
    {
        if (Thread.CurrentThread != this.ownerThread)
            throw new InvalidOperationException();
    }

    public void TakeOwnership()
    {
        this.ownerThread = Thread.CurrentThread;
    }
}

Answer 3

When I run into this situation I use a class I wrote called ThreadAffinity. It's entire purpose is to record the current thread and throw on invalid accesses from a different thread. You have to manually do the check but it encapsulates the small amount of work for you.

class Foo {
  ThreadAffinity affinity = new ThreadAffinity();

  public string SomeProperty {
    get { affinity.Check(); return "Somevalue"; }
  }
}

Class

[Immutable]
public sealed class ThreadAffinity
{
    private readonly int m_threadId;

    public ThreadAffinity()
    {
        m_threadId = Thread.CurrentThread.ManagedThreadId;
    }

    public void Check()
    {
        if (Thread.CurrentThread.ManagedThreadId != m_threadId)
        {
            var msg = String.Format(
                "Call to class with affinity to thread {0} detected from thread {1}.",
                m_threadId,
                Thread.CurrentThread.ManagedThreadId);
            throw new InvalidOperationException(msg);
        }
    }
}

Blog post on the subject:

• http://blogs.msdn.com/jaredpar/archive/2008/02/22/thread-affinity.aspx