I want to use Thread.VolatileWrite() (or an equivalent function) to change the value of a T[] field, so that the updated value is immediately visible to all other threads. However, the method does not provide a generic version, and I'm not able to use the Object overload since it takes a ref parameter.
Is there an alternative? Would Interlocked.Exchange<T> do the job? Is there a better way to achieve what I want to do?
You can maybe use the volatile modifier. But check the documentation to see that the limitation don't apply to your case. And there is probably a performance penalty for using it.
Update: About using Interlocked. Notice that the documentation doesn't state that the changed value is visible to all threads. So it is probably not the same. But if you are in a situation that this is important. You must investigate further all the concurrency disaster possibilities.
VolatileWrite is only useful if you also use VolatileRead; the volatile modifier is easier to use, but I wonder if it wouldn't be simpler to use synchronization - perhaps a ReaderWriterLockSlim (since it sounds like you have lots of readers).
Interlocked.Exchange<T> simply performs the get and set as an atomic operation; it doesn't (AFAIK) make any volatility claims (indeed, the compiler even tells you that a volatile field won't be treated as volatile when used as a ref argument).
Edit to clarify "it doesn't (AFAIK) make any volatility claims" - the behaviour of Interlocked is predictable, and you should see updates immediately on other thread as long as they also use Interlocked; my point is that if one thread uses Interlocked, and another relies on volatile (to talk to the same field), I don't know of any guarantees. Stick to one or the other for all access.