Purpose of this code is to have buffer which will batch messages based on configured timeout. For example, one thread will continuously push data to this buffer, and when configured timeout pass, it will trigger event to process data (like batch and send to external source).
BufferReadyEventArgs.cs
public class BufferReadyEventArgs<T> : EventArgs
{
public BufferReadyEventArgs(List<T> buffer)
{
Buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
}
public List<T> Buffer { get; }
}
TimedBuffer.cs
public class TimedBuffer<T>
{
public event EventHandler<BufferReadyEventArgs<T>> BufferReady;
private readonly object _bufferElapsedSyncRoot = new object();
private readonly object _bufferSyncRoot = new object();
private readonly Timer _processBufferTimer;
private volatile List<T> _buffer = new List<T>();
public TimedBuffer(double intervalInMsecs)
{
_processBufferTimer = new Timer(intervalInMsecs);
_processBufferTimer.Elapsed += _processBufferTimer_Elapsed;
_processBufferTimer.Enabled = true;
}
private void _processBufferTimer_Elapsed(object sender, ElapsedEventArgs e)
{
lock (_bufferElapsedSyncRoot)
{
List<T> readerList = _buffer;
lock (_bufferSyncRoot)
{
_buffer = new List<T>();
}
BufferReady?.Invoke(this, new BufferReadyEventArgs<T>(readerList));
}
}
public void Add(T item)
{
lock (_bufferSyncRoot)
{
_buffer.Add(item);
}
}
}
I would like to have code review for:
- General (like naming, design, code style and etc)
- Performance (Especially locking part)
volatile
keyword? \$\endgroup\$