Simple generic double buffer pattern

Please correct me if I am wrong, but isn't such scenario possible with accepted answer?

public T Swap()
{
    var swappedBuffer = Interlocked.Exchange(ref _current, Next); // 1
    Next = swappedBuffer; // 2
    return swappedBuffer; // 3
}

And it goes like that: (A and B denotes some object of type T):

_current = A
Next = B

Thread 1 executes Line 1: 
swappedBuffer = A
_current = B
Next = B

Thread 2 executes Line 1:
swappedBuffer = B
_current = B
Next = B

Thread 1 executes Line 2:
Next = A

Thread 2 executes Line 2:
Next = B

Now both _current and Next are references to B.

I would start by making sure everything that doesn't need to be public is hidden, and then simplify the Swap method to avoid race conditions.

1. Hide everything except the Swap method. It's not like you gain any real "safety" against incorrect usage (as everyone can cache the result of that method anyway), but at least people don't have to think twice how to use it:

   // we probably won't need the T : class constraint
   public class DoubleBuffer<T>
   {
       private T _current;
       private T _next;
   
       public DoubleBuffer(T current, T next)
       {
           _current = current;
           _next = next;
       }
   
       public T Swap()
       {
            // swap and return previous value
       }
   }
   

2. Preferably, use a simple lock to ensure thread safety. .NET lock (i.e. Monitor) is pretty efficient for short blocks like this. If there is no contention, it's practically free. It also spinlocks for several cycles before it enters kernel mode, meaning that short blocks like this should never put the thread to sleep:

   // this is a no-brainer, simple and without race conditions
   private readonly object _lock = new object();
   public T Swap()
   {
       lock (_lock)
       {
           var previous = _current;
           _current = _next;
           _next = previous;
           return previous;
       }
   }
   

3. If you really want to make sure you're spinlocking, you can use a SpinLock instead (slightly less readable, but nothing spectacular for a method short as this):

   public T Swap()
   {
       var spinlock = new SpinLock();
       var taken = false;
       try
       {
           spinlock.Enter(ref taken);
           var previous = _current;
           _current = _next;
           _next = previous;
           return previous;
       }
       finally
       {
           if (taken)
               spinlock.Exit();
       }
   }
   

4. Finally, if you want to confuse your friends and code reviewers, you can go for something like this, which doesn't really swap values internally, but instead stores them inside an array and toggles the index. And since our class' interface is now simplified (only the Swap method), callers don't need to know out implementation details at all:

   public class DoubleBuffer<T>
   {
       private int _index = 1;
       private T[] _values = new T[2];
   
       public DoubleBuffer(T current, T next)
       {
           _values[0] = current;
           _values[1] = next;
       }
   
       public T Swap()
       {
           // note: _index will overflow after a bunch of calls,
           // but last bit will still be flipped correctly
           var i = Interlocked.Increment(ref _index);
           return _values[i & 1]; // bitwise '&' is cheaper than '%'
       }
   }
   

5. Which can then be slightly generalized and extended to more than just two items (we can also call it a Pool now, although there is no way to let callers "return" objects back to the pool):

   public class Pool<T>
   {
       private int _index = 1;
       private T[] _values;
   
       public Pool(params T[] values)
       {
           if (values == null)
               throw new ArgumentNullException("values cannot be null");
   
           if (values.Length == 0)
               throw new ArgumentOutOfRangeException("values cannot be empty");
   
           _values = (T[])values.Clone(); // @Kuba's comment
       }
   
       public T Swap()
       {
           var i = Interlocked.Increment(ref _index);
           return _values[mod(i, _values.Length)];
       }
   
       // modulo which works nice with negative values
       int mod(int x, int m)
       {
           int r = x % m;
           return r < 0 ? r + m : r;
       }
   }
   

The revised code is also not thread-safe. Although, I suppose as long as you limit its usage to exactly the cases where it would work then you could sort of make that claim. But I suspect that the lock in Swap is pointless in those cases anyways.

I see 4 or 5 ways to break the example code but here's the simplest:

writer1: writeBuf1 = doubleBuf.WriterBuffer;
writer1: ...start writing data to writeBuf1...
   ...writer2 interrupts writer1 thread...
writer2: writeBuf2 = doubleBuf.WriterBuffer;  // writeBuf1 and 2 point to same place
writer2: ...start write data to writeBuf2... // writer2 and 1 data is mixed

The code is definitely not thread-safe.

I quickly see 4 or 5 ways to break the example code but here's the simplest:

writer1: writeBuf1 = doubleBuf.WriterBuffer; writer1: ...start writing data to writeBuf1... ...writer2 interrupts writer1 thread... writer2: writeBuf2 = doubleBuf.WriterBuffer; // writeBuf1 and 2 point to same place writer2: ...start write data to writeBuf2... // writer2 and 1 data is mixed

There's no reason to use double-buffering for what you described.

If you want to make the class thread-safe then you'd need a Read and Write method that extracts/writes the data from/to the buffer. The buffer needs to be protected by a lock in each method. Done.

Even if you wanted to do the double buffer scheme, you'd implement in the exact same way as the single buffer method, via Read/Write methods and locking in those methods. You have to copy the buffer data, you can't ever return direct access to the class's internal buffers if you want to create a thread-safe class unless you also pass ownership along with that buffer.